lucene.py

# ====================================================================
#   Licensed under the Apache License, Version 2.0 (the "License");
#   you may not use this file except in compliance with the License.
#   You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.
# ====================================================================


# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

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('_lucenepp', [dirname(__file__)])
        except ImportError:
            import _lucenepp
            return _lucenepp
        if fp is not None:
            try:
                _mod = imp.load_module('_lucenepp', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _lucenepp = swig_import_helper()
    del swig_import_helper
else:
    import _lucenepp
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) or hasattr(self,name):
        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(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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


SHARED_PTR_DISOWN = _lucenepp.SHARED_PTR_DISOWN

def LuceneObject__equals(*args):
  return _lucenepp.LuceneObject__equals(*args)
LuceneObject__equals = _lucenepp.LuceneObject__equals

def LuceneObject__compare(*args):
  return _lucenepp.LuceneObject__compare(*args)
LuceneObject__compare = _lucenepp.LuceneObject__compare

def LuceneObject__str(*args):
  return _lucenepp.LuceneObject__str(*args)
LuceneObject__str = _lucenepp.LuceneObject__str

def LuceneObject__hash(*args):
  return _lucenepp.LuceneObject__hash(*args)
LuceneObject__hash = _lucenepp.LuceneObject__hash
class Locale(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Locale, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Locale, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_Locale(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Locale
    __del__ = lambda self : None;
    def __str__(self): return _lucenepp.Locale___str__(self)
Locale_swigregister = _lucenepp.Locale_swigregister
Locale_swigregister(Locale)

class LuceneObject(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LuceneObject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LuceneObject, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_LuceneObject
    __del__ = lambda self : None;
    def toString(self): return _lucenepp.LuceneObject_toString(self)
    def __eq__(self, other): return False if other == None else LuceneObject__equals(self, other)
    def __ne__(self, other): return True if other == None else not LuceneObject__equals(self, other)
    def __cmp__(self, other): return LuceneObject__compare(self, other)
    def __str__(self): return LuceneObject__str(self)
    def __hash__(self): return LuceneObject__hash(self)

    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.LuceneObject___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.LuceneObject___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return LuceneObject.__cast_(obj)

LuceneObject_swigregister = _lucenepp.LuceneObject_swigregister
LuceneObject_swigregister(LuceneObject)

def LuceneObject___cast_(*args):
  return _lucenepp.LuceneObject___cast_(*args)
LuceneObject___cast_ = _lucenepp.LuceneObject___cast_

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__ = _lucenepp.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _lucenepp.SwigPyIterator_value(self)
    def incr(self, n = 1): return _lucenepp.SwigPyIterator_incr(self, n)
    def decr(self, n = 1): return _lucenepp.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _lucenepp.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _lucenepp.SwigPyIterator_equal(self, *args)
    def copy(self): return _lucenepp.SwigPyIterator_copy(self)
    def next(self): return _lucenepp.SwigPyIterator_next(self)
    def __next__(self): return _lucenepp.SwigPyIterator___next__(self)
    def previous(self): return _lucenepp.SwigPyIterator_previous(self)
    def advance(self, *args): return _lucenepp.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _lucenepp.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _lucenepp.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _lucenepp.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _lucenepp.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _lucenepp.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _lucenepp.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _lucenepp.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class GenericIterator:
    def __init__(self, begin_iter_method, end_method, deref_method, incr_method):
        self.it = begin_iter_method()
        self.incr   = incr_method
        self.end  = end_method
        self.deref  = deref_method

    def __iter__(self): 
        return self
    def next(self):
        if self.end( self.it ): raise StopIteration
        ret = self.deref( self.it )
        self.incr( self.it )
        return ret

class DoubleCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_DoubleCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.DoubleCollection_clear(self)
    def contains(self, *args): return _lucenepp.DoubleCollection_contains(self, *args)
    def empty(self): return _lucenepp.DoubleCollection_empty(self)
    def remove(self, *args): return _lucenepp.DoubleCollection_remove(self, *args)
    def size(self): return _lucenepp.DoubleCollection_size(self)
    def append(self, *args): return _lucenepp.DoubleCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.DoubleCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.DoubleCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.DoubleCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.DoubleCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.DoubleCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.DoubleCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.DoubleCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.DoubleCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.DoubleCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_DoubleCollection()
        try: self.this.append(this)
        except: self.this = this
DoubleCollection_swigregister = _lucenepp.DoubleCollection_swigregister
DoubleCollection_swigregister(DoubleCollection)

class ByteCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ByteCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ByteCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_ByteCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.ByteCollection_clear(self)
    def contains(self, *args): return _lucenepp.ByteCollection_contains(self, *args)
    def empty(self): return _lucenepp.ByteCollection_empty(self)
    def remove(self, *args): return _lucenepp.ByteCollection_remove(self, *args)
    def size(self): return _lucenepp.ByteCollection_size(self)
    def append(self, *args): return _lucenepp.ByteCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.ByteCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.ByteCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.ByteCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.ByteCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.ByteCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.ByteCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.ByteCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.ByteCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.ByteCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_ByteCollection()
        try: self.this.append(this)
        except: self.this = this
ByteCollection_swigregister = _lucenepp.ByteCollection_swigregister
ByteCollection_swigregister(ByteCollection)

class IntCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_IntCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.IntCollection_clear(self)
    def contains(self, *args): return _lucenepp.IntCollection_contains(self, *args)
    def empty(self): return _lucenepp.IntCollection_empty(self)
    def remove(self, *args): return _lucenepp.IntCollection_remove(self, *args)
    def size(self): return _lucenepp.IntCollection_size(self)
    def append(self, *args): return _lucenepp.IntCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.IntCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.IntCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.IntCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.IntCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.IntCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.IntCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.IntCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.IntCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.IntCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_IntCollection()
        try: self.this.append(this)
        except: self.this = this
IntCollection_swigregister = _lucenepp.IntCollection_swigregister
IntCollection_swigregister(IntCollection)

class LongCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LongCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LongCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_LongCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.LongCollection_clear(self)
    def contains(self, *args): return _lucenepp.LongCollection_contains(self, *args)
    def empty(self): return _lucenepp.LongCollection_empty(self)
    def remove(self, *args): return _lucenepp.LongCollection_remove(self, *args)
    def size(self): return _lucenepp.LongCollection_size(self)
    def append(self, *args): return _lucenepp.LongCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.LongCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.LongCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.LongCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.LongCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.LongCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.LongCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.LongCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.LongCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.LongCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_LongCollection()
        try: self.this.append(this)
        except: self.this = this
LongCollection_swigregister = _lucenepp.LongCollection_swigregister
LongCollection_swigregister(LongCollection)

class StringCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_StringCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.StringCollection_clear(self)
    def contains(self, *args): return _lucenepp.StringCollection_contains(self, *args)
    def empty(self): return _lucenepp.StringCollection_empty(self)
    def remove(self, *args): return _lucenepp.StringCollection_remove(self, *args)
    def size(self): return _lucenepp.StringCollection_size(self)
    def append(self, *args): return _lucenepp.StringCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.StringCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.StringCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.StringCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.StringCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.StringCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.StringCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.StringCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.StringCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.StringCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_StringCollection()
        try: self.this.append(this)
        except: self.this = this
StringCollection_swigregister = _lucenepp.StringCollection_swigregister
StringCollection_swigregister(StringCollection)

class InsanityCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InsanityCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InsanityCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_InsanityCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.InsanityCollection_clear(self)
    def contains(self, *args): return _lucenepp.InsanityCollection_contains(self, *args)
    def empty(self): return _lucenepp.InsanityCollection_empty(self)
    def remove(self, *args): return _lucenepp.InsanityCollection_remove(self, *args)
    def size(self): return _lucenepp.InsanityCollection_size(self)
    def append(self, *args): return _lucenepp.InsanityCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.InsanityCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.InsanityCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.InsanityCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.InsanityCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.InsanityCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.InsanityCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.InsanityCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.InsanityCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.InsanityCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_InsanityCollection()
        try: self.this.append(this)
        except: self.this = this
InsanityCollection_swigregister = _lucenepp.InsanityCollection_swigregister
InsanityCollection_swigregister(InsanityCollection)

class FieldCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FieldCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FieldCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.FieldCollection_clear(self)
    def contains(self, *args): return _lucenepp.FieldCollection_contains(self, *args)
    def empty(self): return _lucenepp.FieldCollection_empty(self)
    def remove(self, *args): return _lucenepp.FieldCollection_remove(self, *args)
    def size(self): return _lucenepp.FieldCollection_size(self)
    def append(self, *args): return _lucenepp.FieldCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.FieldCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.FieldCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.FieldCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.FieldCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.FieldCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.FieldCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.FieldCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.FieldCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.FieldCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_FieldCollection()
        try: self.this.append(this)
        except: self.this = this
FieldCollection_swigregister = _lucenepp.FieldCollection_swigregister
FieldCollection_swigregister(FieldCollection)

class FieldableCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldableCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FieldableCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FieldableCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.FieldableCollection_clear(self)
    def contains(self, *args): return _lucenepp.FieldableCollection_contains(self, *args)
    def empty(self): return _lucenepp.FieldableCollection_empty(self)
    def remove(self, *args): return _lucenepp.FieldableCollection_remove(self, *args)
    def size(self): return _lucenepp.FieldableCollection_size(self)
    def append(self, *args): return _lucenepp.FieldableCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.FieldableCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.FieldableCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.FieldableCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.FieldableCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.FieldableCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.FieldableCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.FieldableCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.FieldableCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.FieldableCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_FieldableCollection()
        try: self.this.append(this)
        except: self.this = this
FieldableCollection_swigregister = _lucenepp.FieldableCollection_swigregister
FieldableCollection_swigregister(FieldableCollection)

class AttributeCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AttributeCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AttributeCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_AttributeCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.AttributeCollection_clear(self)
    def contains(self, *args): return _lucenepp.AttributeCollection_contains(self, *args)
    def empty(self): return _lucenepp.AttributeCollection_empty(self)
    def remove(self, *args): return _lucenepp.AttributeCollection_remove(self, *args)
    def size(self): return _lucenepp.AttributeCollection_size(self)
    def append(self, *args): return _lucenepp.AttributeCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.AttributeCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.AttributeCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.AttributeCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.AttributeCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.AttributeCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.AttributeCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.AttributeCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.AttributeCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.AttributeCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_AttributeCollection()
        try: self.this.append(this)
        except: self.this = this
AttributeCollection_swigregister = _lucenepp.AttributeCollection_swigregister
AttributeCollection_swigregister(AttributeCollection)

class BooleanClauseCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BooleanClauseCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BooleanClauseCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_BooleanClauseCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.BooleanClauseCollection_clear(self)
    def contains(self, *args): return _lucenepp.BooleanClauseCollection_contains(self, *args)
    def empty(self): return _lucenepp.BooleanClauseCollection_empty(self)
    def remove(self, *args): return _lucenepp.BooleanClauseCollection_remove(self, *args)
    def size(self): return _lucenepp.BooleanClauseCollection_size(self)
    def append(self, *args): return _lucenepp.BooleanClauseCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.BooleanClauseCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.BooleanClauseCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.BooleanClauseCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.BooleanClauseCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.BooleanClauseCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.BooleanClauseCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.BooleanClauseCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.BooleanClauseCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.BooleanClauseCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_BooleanClauseCollection()
        try: self.this.append(this)
        except: self.this = this
BooleanClauseCollection_swigregister = _lucenepp.BooleanClauseCollection_swigregister
BooleanClauseCollection_swigregister(BooleanClauseCollection)

class BooleanQueryCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BooleanQueryCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BooleanQueryCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_BooleanQueryCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.BooleanQueryCollection_clear(self)
    def contains(self, *args): return _lucenepp.BooleanQueryCollection_contains(self, *args)
    def empty(self): return _lucenepp.BooleanQueryCollection_empty(self)
    def remove(self, *args): return _lucenepp.BooleanQueryCollection_remove(self, *args)
    def size(self): return _lucenepp.BooleanQueryCollection_size(self)
    def append(self, *args): return _lucenepp.BooleanQueryCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.BooleanQueryCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.BooleanQueryCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.BooleanQueryCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.BooleanQueryCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.BooleanQueryCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.BooleanQueryCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.BooleanQueryCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.BooleanQueryCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.BooleanQueryCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_BooleanQueryCollection()
        try: self.this.append(this)
        except: self.this = this
BooleanQueryCollection_swigregister = _lucenepp.BooleanQueryCollection_swigregister
BooleanQueryCollection_swigregister(BooleanQueryCollection)

class DirectoryCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DirectoryCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DirectoryCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_DirectoryCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.DirectoryCollection_clear(self)
    def contains(self, *args): return _lucenepp.DirectoryCollection_contains(self, *args)
    def empty(self): return _lucenepp.DirectoryCollection_empty(self)
    def remove(self, *args): return _lucenepp.DirectoryCollection_remove(self, *args)
    def size(self): return _lucenepp.DirectoryCollection_size(self)
    def append(self, *args): return _lucenepp.DirectoryCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.DirectoryCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.DirectoryCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.DirectoryCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.DirectoryCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.DirectoryCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.DirectoryCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.DirectoryCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.DirectoryCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.DirectoryCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_DirectoryCollection()
        try: self.this.append(this)
        except: self.this = this
DirectoryCollection_swigregister = _lucenepp.DirectoryCollection_swigregister
DirectoryCollection_swigregister(DirectoryCollection)

class ExplanationCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExplanationCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExplanationCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_ExplanationCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.ExplanationCollection_clear(self)
    def contains(self, *args): return _lucenepp.ExplanationCollection_contains(self, *args)
    def empty(self): return _lucenepp.ExplanationCollection_empty(self)
    def remove(self, *args): return _lucenepp.ExplanationCollection_remove(self, *args)
    def size(self): return _lucenepp.ExplanationCollection_size(self)
    def append(self, *args): return _lucenepp.ExplanationCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.ExplanationCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.ExplanationCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.ExplanationCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.ExplanationCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.ExplanationCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.ExplanationCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.ExplanationCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.ExplanationCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.ExplanationCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_ExplanationCollection()
        try: self.this.append(this)
        except: self.this = this
ExplanationCollection_swigregister = _lucenepp.ExplanationCollection_swigregister
ExplanationCollection_swigregister(ExplanationCollection)

class FieldCacheEntryCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldCacheEntryCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FieldCacheEntryCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FieldCacheEntryCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.FieldCacheEntryCollection_clear(self)
    def contains(self, *args): return _lucenepp.FieldCacheEntryCollection_contains(self, *args)
    def empty(self): return _lucenepp.FieldCacheEntryCollection_empty(self)
    def remove(self, *args): return _lucenepp.FieldCacheEntryCollection_remove(self, *args)
    def size(self): return _lucenepp.FieldCacheEntryCollection_size(self)
    def append(self, *args): return _lucenepp.FieldCacheEntryCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.FieldCacheEntryCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.FieldCacheEntryCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.FieldCacheEntryCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.FieldCacheEntryCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.FieldCacheEntryCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.FieldCacheEntryCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.FieldCacheEntryCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.FieldCacheEntryCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.FieldCacheEntryCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_FieldCacheEntryCollection()
        try: self.this.append(this)
        except: self.this = this
FieldCacheEntryCollection_swigregister = _lucenepp.FieldCacheEntryCollection_swigregister
FieldCacheEntryCollection_swigregister(FieldCacheEntryCollection)

class FieldComparatorCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldComparatorCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FieldComparatorCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FieldComparatorCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.FieldComparatorCollection_clear(self)
    def contains(self, *args): return _lucenepp.FieldComparatorCollection_contains(self, *args)
    def empty(self): return _lucenepp.FieldComparatorCollection_empty(self)
    def remove(self, *args): return _lucenepp.FieldComparatorCollection_remove(self, *args)
    def size(self): return _lucenepp.FieldComparatorCollection_size(self)
    def append(self, *args): return _lucenepp.FieldComparatorCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.FieldComparatorCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.FieldComparatorCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.FieldComparatorCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.FieldComparatorCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.FieldComparatorCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.FieldComparatorCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.FieldComparatorCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.FieldComparatorCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.FieldComparatorCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_FieldComparatorCollection()
        try: self.this.append(this)
        except: self.this = this
FieldComparatorCollection_swigregister = _lucenepp.FieldComparatorCollection_swigregister
FieldComparatorCollection_swigregister(FieldComparatorCollection)

class IndexCommitCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndexCommitCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IndexCommitCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_IndexCommitCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.IndexCommitCollection_clear(self)
    def contains(self, *args): return _lucenepp.IndexCommitCollection_contains(self, *args)
    def empty(self): return _lucenepp.IndexCommitCollection_empty(self)
    def remove(self, *args): return _lucenepp.IndexCommitCollection_remove(self, *args)
    def size(self): return _lucenepp.IndexCommitCollection_size(self)
    def append(self, *args): return _lucenepp.IndexCommitCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.IndexCommitCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.IndexCommitCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.IndexCommitCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.IndexCommitCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.IndexCommitCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.IndexCommitCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.IndexCommitCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.IndexCommitCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.IndexCommitCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_IndexCommitCollection()
        try: self.this.append(this)
        except: self.this = this
IndexCommitCollection_swigregister = _lucenepp.IndexCommitCollection_swigregister
IndexCommitCollection_swigregister(IndexCommitCollection)

class IndexReaderCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndexReaderCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IndexReaderCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_IndexReaderCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.IndexReaderCollection_clear(self)
    def contains(self, *args): return _lucenepp.IndexReaderCollection_contains(self, *args)
    def empty(self): return _lucenepp.IndexReaderCollection_empty(self)
    def remove(self, *args): return _lucenepp.IndexReaderCollection_remove(self, *args)
    def size(self): return _lucenepp.IndexReaderCollection_size(self)
    def append(self, *args): return _lucenepp.IndexReaderCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.IndexReaderCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.IndexReaderCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.IndexReaderCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.IndexReaderCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.IndexReaderCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.IndexReaderCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.IndexReaderCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.IndexReaderCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.IndexReaderCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_IndexReaderCollection()
        try: self.this.append(this)
        except: self.this = this
IndexReaderCollection_swigregister = _lucenepp.IndexReaderCollection_swigregister
IndexReaderCollection_swigregister(IndexReaderCollection)

class OneMergeCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OneMergeCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OneMergeCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_OneMergeCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.OneMergeCollection_clear(self)
    def contains(self, *args): return _lucenepp.OneMergeCollection_contains(self, *args)
    def empty(self): return _lucenepp.OneMergeCollection_empty(self)
    def remove(self, *args): return _lucenepp.OneMergeCollection_remove(self, *args)
    def size(self): return _lucenepp.OneMergeCollection_size(self)
    def append(self, *args): return _lucenepp.OneMergeCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.OneMergeCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.OneMergeCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.OneMergeCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.OneMergeCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.OneMergeCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.OneMergeCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.OneMergeCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.OneMergeCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.OneMergeCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_OneMergeCollection()
        try: self.this.append(this)
        except: self.this = this
OneMergeCollection_swigregister = _lucenepp.OneMergeCollection_swigregister
OneMergeCollection_swigregister(OneMergeCollection)

class PositionInfoCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PositionInfoCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PositionInfoCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_PositionInfoCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.PositionInfoCollection_clear(self)
    def contains(self, *args): return _lucenepp.PositionInfoCollection_contains(self, *args)
    def empty(self): return _lucenepp.PositionInfoCollection_empty(self)
    def remove(self, *args): return _lucenepp.PositionInfoCollection_remove(self, *args)
    def size(self): return _lucenepp.PositionInfoCollection_size(self)
    def append(self, *args): return _lucenepp.PositionInfoCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.PositionInfoCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.PositionInfoCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.PositionInfoCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.PositionInfoCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.PositionInfoCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.PositionInfoCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.PositionInfoCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.PositionInfoCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.PositionInfoCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_PositionInfoCollection()
        try: self.this.append(this)
        except: self.this = this
PositionInfoCollection_swigregister = _lucenepp.PositionInfoCollection_swigregister
PositionInfoCollection_swigregister(PositionInfoCollection)

class QueryCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QueryCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QueryCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_QueryCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.QueryCollection_clear(self)
    def contains(self, *args): return _lucenepp.QueryCollection_contains(self, *args)
    def empty(self): return _lucenepp.QueryCollection_empty(self)
    def remove(self, *args): return _lucenepp.QueryCollection_remove(self, *args)
    def size(self): return _lucenepp.QueryCollection_size(self)
    def append(self, *args): return _lucenepp.QueryCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.QueryCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.QueryCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.QueryCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.QueryCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.QueryCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.QueryCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.QueryCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.QueryCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.QueryCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_QueryCollection()
        try: self.this.append(this)
        except: self.this = this
QueryCollection_swigregister = _lucenepp.QueryCollection_swigregister
QueryCollection_swigregister(QueryCollection)

class ScoreDocCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScoreDocCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScoreDocCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_ScoreDocCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.ScoreDocCollection_clear(self)
    def contains(self, *args): return _lucenepp.ScoreDocCollection_contains(self, *args)
    def empty(self): return _lucenepp.ScoreDocCollection_empty(self)
    def remove(self, *args): return _lucenepp.ScoreDocCollection_remove(self, *args)
    def size(self): return _lucenepp.ScoreDocCollection_size(self)
    def append(self, *args): return _lucenepp.ScoreDocCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.ScoreDocCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.ScoreDocCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.ScoreDocCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.ScoreDocCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.ScoreDocCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.ScoreDocCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.ScoreDocCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.ScoreDocCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.ScoreDocCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_ScoreDocCollection()
        try: self.this.append(this)
        except: self.this = this
ScoreDocCollection_swigregister = _lucenepp.ScoreDocCollection_swigregister
ScoreDocCollection_swigregister(ScoreDocCollection)

class SearchableCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SearchableCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SearchableCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SearchableCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.SearchableCollection_clear(self)
    def contains(self, *args): return _lucenepp.SearchableCollection_contains(self, *args)
    def empty(self): return _lucenepp.SearchableCollection_empty(self)
    def remove(self, *args): return _lucenepp.SearchableCollection_remove(self, *args)
    def size(self): return _lucenepp.SearchableCollection_size(self)
    def append(self, *args): return _lucenepp.SearchableCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.SearchableCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.SearchableCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.SearchableCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.SearchableCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.SearchableCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.SearchableCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.SearchableCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.SearchableCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.SearchableCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_SearchableCollection()
        try: self.this.append(this)
        except: self.this = this
SearchableCollection_swigregister = _lucenepp.SearchableCollection_swigregister
SearchableCollection_swigregister(SearchableCollection)

class SegmentInfoStatusCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SegmentInfoStatusCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SegmentInfoStatusCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SegmentInfoStatusCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.SegmentInfoStatusCollection_clear(self)
    def contains(self, *args): return _lucenepp.SegmentInfoStatusCollection_contains(self, *args)
    def empty(self): return _lucenepp.SegmentInfoStatusCollection_empty(self)
    def remove(self, *args): return _lucenepp.SegmentInfoStatusCollection_remove(self, *args)
    def size(self): return _lucenepp.SegmentInfoStatusCollection_size(self)
    def append(self, *args): return _lucenepp.SegmentInfoStatusCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.SegmentInfoStatusCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.SegmentInfoStatusCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.SegmentInfoStatusCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.SegmentInfoStatusCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.SegmentInfoStatusCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.SegmentInfoStatusCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.SegmentInfoStatusCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.SegmentInfoStatusCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.SegmentInfoStatusCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_SegmentInfoStatusCollection()
        try: self.this.append(this)
        except: self.this = this
SegmentInfoStatusCollection_swigregister = _lucenepp.SegmentInfoStatusCollection_swigregister
SegmentInfoStatusCollection_swigregister(SegmentInfoStatusCollection)

class SegmentReaderCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SegmentReaderCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SegmentReaderCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SegmentReaderCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.SegmentReaderCollection_clear(self)
    def contains(self, *args): return _lucenepp.SegmentReaderCollection_contains(self, *args)
    def empty(self): return _lucenepp.SegmentReaderCollection_empty(self)
    def remove(self, *args): return _lucenepp.SegmentReaderCollection_remove(self, *args)
    def size(self): return _lucenepp.SegmentReaderCollection_size(self)
    def append(self, *args): return _lucenepp.SegmentReaderCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.SegmentReaderCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.SegmentReaderCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.SegmentReaderCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.SegmentReaderCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.SegmentReaderCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.SegmentReaderCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.SegmentReaderCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.SegmentReaderCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.SegmentReaderCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_SegmentReaderCollection()
        try: self.this.append(this)
        except: self.this = this
SegmentReaderCollection_swigregister = _lucenepp.SegmentReaderCollection_swigregister
SegmentReaderCollection_swigregister(SegmentReaderCollection)

class SortFieldCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SortFieldCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SortFieldCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SortFieldCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.SortFieldCollection_clear(self)
    def contains(self, *args): return _lucenepp.SortFieldCollection_contains(self, *args)
    def empty(self): return _lucenepp.SortFieldCollection_empty(self)
    def remove(self, *args): return _lucenepp.SortFieldCollection_remove(self, *args)
    def size(self): return _lucenepp.SortFieldCollection_size(self)
    def append(self, *args): return _lucenepp.SortFieldCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.SortFieldCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.SortFieldCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.SortFieldCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.SortFieldCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.SortFieldCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.SortFieldCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.SortFieldCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.SortFieldCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.SortFieldCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_SortFieldCollection()
        try: self.this.append(this)
        except: self.this = this
SortFieldCollection_swigregister = _lucenepp.SortFieldCollection_swigregister
SortFieldCollection_swigregister(SortFieldCollection)

class SpanQueryCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanQueryCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SpanQueryCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SpanQueryCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.SpanQueryCollection_clear(self)
    def contains(self, *args): return _lucenepp.SpanQueryCollection_contains(self, *args)
    def empty(self): return _lucenepp.SpanQueryCollection_empty(self)
    def remove(self, *args): return _lucenepp.SpanQueryCollection_remove(self, *args)
    def size(self): return _lucenepp.SpanQueryCollection_size(self)
    def append(self, *args): return _lucenepp.SpanQueryCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.SpanQueryCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.SpanQueryCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.SpanQueryCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.SpanQueryCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.SpanQueryCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.SpanQueryCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.SpanQueryCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.SpanQueryCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.SpanQueryCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_SpanQueryCollection()
        try: self.this.append(this)
        except: self.this = this
SpanQueryCollection_swigregister = _lucenepp.SpanQueryCollection_swigregister
SpanQueryCollection_swigregister(SpanQueryCollection)

class SpansCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpansCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SpansCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SpansCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.SpansCollection_clear(self)
    def contains(self, *args): return _lucenepp.SpansCollection_contains(self, *args)
    def empty(self): return _lucenepp.SpansCollection_empty(self)
    def remove(self, *args): return _lucenepp.SpansCollection_remove(self, *args)
    def size(self): return _lucenepp.SpansCollection_size(self)
    def append(self, *args): return _lucenepp.SpansCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.SpansCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.SpansCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.SpansCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.SpansCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.SpansCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.SpansCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.SpansCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.SpansCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.SpansCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_SpansCollection()
        try: self.this.append(this)
        except: self.this = this
SpansCollection_swigregister = _lucenepp.SpansCollection_swigregister
SpansCollection_swigregister(SpansCollection)

class StartEndCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StartEndCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StartEndCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_StartEndCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.StartEndCollection_clear(self)
    def contains(self, *args): return _lucenepp.StartEndCollection_contains(self, *args)
    def empty(self): return _lucenepp.StartEndCollection_empty(self)
    def remove(self, *args): return _lucenepp.StartEndCollection_remove(self, *args)
    def size(self): return _lucenepp.StartEndCollection_size(self)
    def append(self, *args): return _lucenepp.StartEndCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.StartEndCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.StartEndCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.StartEndCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.StartEndCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.StartEndCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.StartEndCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.StartEndCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.StartEndCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.StartEndCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_StartEndCollection()
        try: self.this.append(this)
        except: self.this = this
StartEndCollection_swigregister = _lucenepp.StartEndCollection_swigregister
StartEndCollection_swigregister(StartEndCollection)

class TermFreqVectorCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermFreqVectorCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TermFreqVectorCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TermFreqVectorCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.TermFreqVectorCollection_clear(self)
    def contains(self, *args): return _lucenepp.TermFreqVectorCollection_contains(self, *args)
    def empty(self): return _lucenepp.TermFreqVectorCollection_empty(self)
    def remove(self, *args): return _lucenepp.TermFreqVectorCollection_remove(self, *args)
    def size(self): return _lucenepp.TermFreqVectorCollection_size(self)
    def append(self, *args): return _lucenepp.TermFreqVectorCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.TermFreqVectorCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.TermFreqVectorCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.TermFreqVectorCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.TermFreqVectorCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.TermFreqVectorCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.TermFreqVectorCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.TermFreqVectorCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.TermFreqVectorCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.TermFreqVectorCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_TermFreqVectorCollection()
        try: self.this.append(this)
        except: self.this = this
TermFreqVectorCollection_swigregister = _lucenepp.TermFreqVectorCollection_swigregister
TermFreqVectorCollection_swigregister(TermFreqVectorCollection)

class TermVectorEntryCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermVectorEntryCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TermVectorEntryCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TermVectorEntryCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.TermVectorEntryCollection_clear(self)
    def contains(self, *args): return _lucenepp.TermVectorEntryCollection_contains(self, *args)
    def empty(self): return _lucenepp.TermVectorEntryCollection_empty(self)
    def remove(self, *args): return _lucenepp.TermVectorEntryCollection_remove(self, *args)
    def size(self): return _lucenepp.TermVectorEntryCollection_size(self)
    def append(self, *args): return _lucenepp.TermVectorEntryCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.TermVectorEntryCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.TermVectorEntryCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.TermVectorEntryCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.TermVectorEntryCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.TermVectorEntryCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.TermVectorEntryCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.TermVectorEntryCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.TermVectorEntryCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.TermVectorEntryCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_TermVectorEntryCollection()
        try: self.this.append(this)
        except: self.this = this
TermVectorEntryCollection_swigregister = _lucenepp.TermVectorEntryCollection_swigregister
TermVectorEntryCollection_swigregister(TermVectorEntryCollection)

class TermVectorOffsetInfoCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermVectorOffsetInfoCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TermVectorOffsetInfoCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TermVectorOffsetInfoCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.TermVectorOffsetInfoCollection_clear(self)
    def contains(self, *args): return _lucenepp.TermVectorOffsetInfoCollection_contains(self, *args)
    def empty(self): return _lucenepp.TermVectorOffsetInfoCollection_empty(self)
    def remove(self, *args): return _lucenepp.TermVectorOffsetInfoCollection_remove(self, *args)
    def size(self): return _lucenepp.TermVectorOffsetInfoCollection_size(self)
    def append(self, *args): return _lucenepp.TermVectorOffsetInfoCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.TermVectorOffsetInfoCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.TermVectorOffsetInfoCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.TermVectorOffsetInfoCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.TermVectorOffsetInfoCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.TermVectorOffsetInfoCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.TermVectorOffsetInfoCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.TermVectorOffsetInfoCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.TermVectorOffsetInfoCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.TermVectorOffsetInfoCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_TermVectorOffsetInfoCollection()
        try: self.this.append(this)
        except: self.this = this
TermVectorOffsetInfoCollection_swigregister = _lucenepp.TermVectorOffsetInfoCollection_swigregister
TermVectorOffsetInfoCollection_swigregister(TermVectorOffsetInfoCollection)

class ValueSourceQueryCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ValueSourceQueryCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ValueSourceQueryCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_ValueSourceQueryCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.ValueSourceQueryCollection_clear(self)
    def contains(self, *args): return _lucenepp.ValueSourceQueryCollection_contains(self, *args)
    def empty(self): return _lucenepp.ValueSourceQueryCollection_empty(self)
    def remove(self, *args): return _lucenepp.ValueSourceQueryCollection_remove(self, *args)
    def size(self): return _lucenepp.ValueSourceQueryCollection_size(self)
    def append(self, *args): return _lucenepp.ValueSourceQueryCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.ValueSourceQueryCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.ValueSourceQueryCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.ValueSourceQueryCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.ValueSourceQueryCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.ValueSourceQueryCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.ValueSourceQueryCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.ValueSourceQueryCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.ValueSourceQueryCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.ValueSourceQueryCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_ValueSourceQueryCollection()
        try: self.this.append(this)
        except: self.this = this
ValueSourceQueryCollection_swigregister = _lucenepp.ValueSourceQueryCollection_swigregister
ValueSourceQueryCollection_swigregister(ValueSourceQueryCollection)

class BooleanClauseOccurCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BooleanClauseOccurCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BooleanClauseOccurCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_BooleanClauseOccurCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.BooleanClauseOccurCollection_clear(self)
    def contains(self, *args): return _lucenepp.BooleanClauseOccurCollection_contains(self, *args)
    def empty(self): return _lucenepp.BooleanClauseOccurCollection_empty(self)
    def remove(self, *args): return _lucenepp.BooleanClauseOccurCollection_remove(self, *args)
    def size(self): return _lucenepp.BooleanClauseOccurCollection_size(self)
    def append(self, *args): return _lucenepp.BooleanClauseOccurCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.BooleanClauseOccurCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.BooleanClauseOccurCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.BooleanClauseOccurCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.BooleanClauseOccurCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.BooleanClauseOccurCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.BooleanClauseOccurCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.BooleanClauseOccurCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.BooleanClauseOccurCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.BooleanClauseOccurCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_BooleanClauseOccurCollection()
        try: self.this.append(this)
        except: self.this = this
BooleanClauseOccurCollection_swigregister = _lucenepp.BooleanClauseOccurCollection_swigregister
BooleanClauseOccurCollection_swigregister(BooleanClauseOccurCollection)

class TermCollection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TermCollection, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TermCollection
    __del__ = lambda self : None;
    def clear(self): return _lucenepp.TermCollection_clear(self)
    def contains(self, *args): return _lucenepp.TermCollection_contains(self, *args)
    def empty(self): return _lucenepp.TermCollection_empty(self)
    def remove(self, *args): return _lucenepp.TermCollection_remove(self, *args)
    def size(self): return _lucenepp.TermCollection_size(self)
    def append(self, *args): return _lucenepp.TermCollection_append(self, *args)
    def __setitem__(self, *args): return _lucenepp.TermCollection___setitem__(self, *args)
    def __getitem__(self, *args): return _lucenepp.TermCollection___getitem__(self, *args)
    def __delitem__(self, *args): return _lucenepp.TermCollection___delitem__(self, *args)
    def __ne__(self, *args): return _lucenepp.TermCollection___ne__(self, *args)
    def __eq__(self, *args): return _lucenepp.TermCollection___eq__(self, *args)
    def __hash__(self): return _lucenepp.TermCollection___hash__(self)
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator(
                self._begin___iter__,
                self._end__iter__,
                self._deref___iter__,
                _iter_incr
                 )

    def _begin___iter__(self): return _lucenepp.TermCollection__begin___iter__(self)
    def _deref___iter__(self, *args): return _lucenepp.TermCollection__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.TermCollection__end__iter__(self, *args)
    def __init__(self): 
        this = _lucenepp.new_TermCollection()
        try: self.this.append(this)
        except: self.this = this
TermCollection_swigregister = _lucenepp.TermCollection_swigregister
TermCollection_swigregister(TermCollection)

class MapStringDouble(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringDouble, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapStringDouble, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_MapStringDouble
    __del__ = lambda self : None;
    def reset(self): return _lucenepp.MapStringDouble_reset(self)
    def size(self): return _lucenepp.MapStringDouble_size(self)
    def empty(self): return _lucenepp.MapStringDouble_empty(self)
    def clear(self): return _lucenepp.MapStringDouble_clear(self)
    def put(self, *args): return _lucenepp.MapStringDouble_put(self, *args)
    def remove(self, *args): return _lucenepp.MapStringDouble_remove(self, *args)
    def get(self, *args): return _lucenepp.MapStringDouble_get(self, *args)
    def contains(self, *args): return _lucenepp.MapStringDouble_contains(self, *args)
    def __init__(self): 
        this = _lucenepp.new_MapStringDouble()
        try: self.this.append(this)
        except: self.this = this
MapStringDouble_swigregister = _lucenepp.MapStringDouble_swigregister
MapStringDouble_swigregister(MapStringDouble)

class MapStringAnalyzer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringAnalyzer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapStringAnalyzer, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_MapStringAnalyzer
    __del__ = lambda self : None;
    def reset(self): return _lucenepp.MapStringAnalyzer_reset(self)
    def size(self): return _lucenepp.MapStringAnalyzer_size(self)
    def empty(self): return _lucenepp.MapStringAnalyzer_empty(self)
    def clear(self): return _lucenepp.MapStringAnalyzer_clear(self)
    def put(self, *args): return _lucenepp.MapStringAnalyzer_put(self, *args)
    def remove(self, *args): return _lucenepp.MapStringAnalyzer_remove(self, *args)
    def get(self, *args): return _lucenepp.MapStringAnalyzer_get(self, *args)
    def contains(self, *args): return _lucenepp.MapStringAnalyzer_contains(self, *args)
    def __init__(self): 
        this = _lucenepp.new_MapStringAnalyzer()
        try: self.this.append(this)
        except: self.this = this
MapStringAnalyzer_swigregister = _lucenepp.MapStringAnalyzer_swigregister
MapStringAnalyzer_swigregister(MapStringAnalyzer)

class MapStringCollectionTermVectorEntry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringCollectionTermVectorEntry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapStringCollectionTermVectorEntry, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_MapStringCollectionTermVectorEntry
    __del__ = lambda self : None;
    def reset(self): return _lucenepp.MapStringCollectionTermVectorEntry_reset(self)
    def size(self): return _lucenepp.MapStringCollectionTermVectorEntry_size(self)
    def empty(self): return _lucenepp.MapStringCollectionTermVectorEntry_empty(self)
    def clear(self): return _lucenepp.MapStringCollectionTermVectorEntry_clear(self)
    def put(self, *args): return _lucenepp.MapStringCollectionTermVectorEntry_put(self, *args)
    def remove(self, *args): return _lucenepp.MapStringCollectionTermVectorEntry_remove(self, *args)
    def get(self, *args): return _lucenepp.MapStringCollectionTermVectorEntry_get(self, *args)
    def contains(self, *args): return _lucenepp.MapStringCollectionTermVectorEntry_contains(self, *args)
    def __init__(self): 
        this = _lucenepp.new_MapStringCollectionTermVectorEntry()
        try: self.this.append(this)
        except: self.this = this
MapStringCollectionTermVectorEntry_swigregister = _lucenepp.MapStringCollectionTermVectorEntry_swigregister
MapStringCollectionTermVectorEntry_swigregister(MapStringCollectionTermVectorEntry)

class MapStringString(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringString, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapStringString, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_MapStringString
    __del__ = lambda self : None;
    def reset(self): return _lucenepp.MapStringString_reset(self)
    def size(self): return _lucenepp.MapStringString_size(self)
    def empty(self): return _lucenepp.MapStringString_empty(self)
    def clear(self): return _lucenepp.MapStringString_clear(self)
    def put(self, *args): return _lucenepp.MapStringString_put(self, *args)
    def remove(self, *args): return _lucenepp.MapStringString_remove(self, *args)
    def get(self, *args): return _lucenepp.MapStringString_get(self, *args)
    def contains(self, *args): return _lucenepp.MapStringString_contains(self, *args)
    def __init__(self): 
        this = _lucenepp.new_MapStringString()
        try: self.this.append(this)
        except: self.this = this
MapStringString_swigregister = _lucenepp.MapStringString_swigregister
MapStringString_swigregister(MapStringString)

class MapStringFieldSelectorResult(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapStringFieldSelectorResult, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapStringFieldSelectorResult, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_MapStringFieldSelectorResult
    __del__ = lambda self : None;
    def reset(self): return _lucenepp.MapStringFieldSelectorResult_reset(self)
    def size(self): return _lucenepp.MapStringFieldSelectorResult_size(self)
    def empty(self): return _lucenepp.MapStringFieldSelectorResult_empty(self)
    def clear(self): return _lucenepp.MapStringFieldSelectorResult_clear(self)
    def put(self, *args): return _lucenepp.MapStringFieldSelectorResult_put(self, *args)
    def remove(self, *args): return _lucenepp.MapStringFieldSelectorResult_remove(self, *args)
    def get(self, *args): return _lucenepp.MapStringFieldSelectorResult_get(self, *args)
    def contains(self, *args): return _lucenepp.MapStringFieldSelectorResult_contains(self, *args)
    def __init__(self): 
        this = _lucenepp.new_MapStringFieldSelectorResult()
        try: self.this.append(this)
        except: self.this = this
MapStringFieldSelectorResult_swigregister = _lucenepp.MapStringFieldSelectorResult_swigregister
MapStringFieldSelectorResult_swigregister(MapStringFieldSelectorResult)

class SetSegmentInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SetSegmentInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SetSegmentInfo, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SetSegmentInfo
    __del__ = lambda self : None;
    def reset(self): return _lucenepp.SetSegmentInfo_reset(self)
    def size(self): return _lucenepp.SetSegmentInfo_size(self)
    def empty(self): return _lucenepp.SetSegmentInfo_empty(self)
    def clear(self): return _lucenepp.SetSegmentInfo_clear(self)
    def add(self, *args): return _lucenepp.SetSegmentInfo_add(self, *args)
    def remove(self, *args): return _lucenepp.SetSegmentInfo_remove(self, *args)
    def contains(self, *args): return _lucenepp.SetSegmentInfo_contains(self, *args)
    def _deref___iter__(self, *args): return _lucenepp.SetSegmentInfo__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.SetSegmentInfo__end__iter__(self, *args)
    def _begin__iter__(self): return _lucenepp.SetSegmentInfo__begin__iter__(self)
    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator( self._begin__iter__, self._end__iter__, self._deref___iter__, _iter_incr )
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __init__(self): 
        this = _lucenepp.new_SetSegmentInfo()
        try: self.this.append(this)
        except: self.this = this
SetSegmentInfo_swigregister = _lucenepp.SetSegmentInfo_swigregister
SetSegmentInfo_swigregister(SetSegmentInfo)

class SetTerm(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SetTerm, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SetTerm, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SetTerm
    __del__ = lambda self : None;
    def reset(self): return _lucenepp.SetTerm_reset(self)
    def size(self): return _lucenepp.SetTerm_size(self)
    def empty(self): return _lucenepp.SetTerm_empty(self)
    def clear(self): return _lucenepp.SetTerm_clear(self)
    def add(self, *args): return _lucenepp.SetTerm_add(self, *args)
    def remove(self, *args): return _lucenepp.SetTerm_remove(self, *args)
    def contains(self, *args): return _lucenepp.SetTerm_contains(self, *args)
    def _deref___iter__(self, *args): return _lucenepp.SetTerm__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.SetTerm__end__iter__(self, *args)
    def _begin__iter__(self): return _lucenepp.SetTerm__begin__iter__(self)
    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator( self._begin__iter__, self._end__iter__, self._deref___iter__, _iter_incr )
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __init__(self): 
        this = _lucenepp.new_SetTerm()
        try: self.this.append(this)
        except: self.this = this
SetTerm_swigregister = _lucenepp.SetTerm_swigregister
SetTerm_swigregister(SetTerm)

class SetString(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SetString, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SetString, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SetString
    __del__ = lambda self : None;
    def reset(self): return _lucenepp.SetString_reset(self)
    def size(self): return _lucenepp.SetString_size(self)
    def empty(self): return _lucenepp.SetString_empty(self)
    def clear(self): return _lucenepp.SetString_clear(self)
    def add(self, *args): return _lucenepp.SetString_add(self, *args)
    def remove(self, *args): return _lucenepp.SetString_remove(self, *args)
    def contains(self, *args): return _lucenepp.SetString_contains(self, *args)
    def _deref___iter__(self, *args): return _lucenepp.SetString__deref___iter__(self, *args)
    def _end__iter__(self, *args): return _lucenepp.SetString__end__iter__(self, *args)
    def _begin__iter__(self): return _lucenepp.SetString__begin__iter__(self)
    def __iter__(self):
        "Returns an iterator for __iter__."
        return GenericIterator( self._begin__iter__, self._end__iter__, self._deref___iter__, _iter_incr )
    def __contains__(self, v): return self.contains(v)
    def __len__(self): return self.size()
    def __str__(self): return "[" + ", ".join([`item` for item in self]) + "]"

    def __init__(self): 
        this = _lucenepp.new_SetString()
        try: self.this.append(this)
        except: self.this = this
SetString_swigregister = _lucenepp.SetString_swigregister
SetString_swigregister(SetString)

def _iter_incr(*args):
  return _lucenepp._iter_incr(*args)
_iter_incr = _lucenepp._iter_incr

class Reader(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Reader, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Reader, name)
    __repr__ = _swig_repr
    def __init__(self): 
        if self.__class__ == Reader:
            _self = None
        else:
            _self = self
        this = _lucenepp.new_Reader(_self, )
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Reader
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Reader_getClassName(self)
    def read(self, *args): return _lucenepp.Reader_read(self, *args)
    def skip(self, *args): return _lucenepp.Reader_skip(self, *args)
    def close(self): return _lucenepp.Reader_close(self)
    def markSupported(self): return _lucenepp.Reader_markSupported(self)
    def mark(self, *args): return _lucenepp.Reader_mark(self, *args)
    def reset(self): return _lucenepp.Reader_reset(self)
    def length(self): return _lucenepp.Reader_length(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Reader___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Reader___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Reader.__cast_(obj)

    def __disown__(self):
        self.this.disown()
        _lucenepp.disown_Reader(self)
        return weakref_proxy(self)
Reader_swigregister = _lucenepp.Reader_swigregister
Reader_swigregister(Reader)
cvar = _lucenepp.cvar
Reader.READER_EOF = _lucenepp.cvar.Reader_READER_EOF

def Reader___cast_(*args):
  return _lucenepp.Reader___cast_(*args)
Reader___cast_ = _lucenepp.Reader___cast_

class StringReader(Reader):
    __swig_setmethods__ = {}
    for _s in [Reader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringReader, name, value)
    __swig_getmethods__ = {}
    for _s in [Reader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StringReader, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_StringReader(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_StringReader
    __del__ = lambda self : None;
    def read(self, *args): return _lucenepp.StringReader_read(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.StringReader___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.StringReader___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return StringReader.__cast_(obj)

StringReader_swigregister = _lucenepp.StringReader_swigregister
StringReader_swigregister(StringReader)

def StringReader___cast_(*args):
  return _lucenepp.StringReader___cast_(*args)
StringReader___cast_ = _lucenepp.StringReader___cast_

class Attribute(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Attribute, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Attribute, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Attribute
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Attribute_getClassName(self)
    def clear(self): return _lucenepp.Attribute_clear(self)
    def copyTo(self, *args): return _lucenepp.Attribute_copyTo(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Attribute___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Attribute___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Attribute.__cast_(obj)

Attribute_swigregister = _lucenepp.Attribute_swigregister
Attribute_swigregister(Attribute)

def Attribute___cast_(*args):
  return _lucenepp.Attribute___cast_(*args)
Attribute___cast_ = _lucenepp.Attribute___cast_

class AttributeFactory(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AttributeFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AttributeFactory, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_AttributeFactory
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.AttributeFactory_getClassName(self)
    def createAttributeInstance(self, *args): return _lucenepp.AttributeFactory_createAttributeInstance(self, *args)
    __swig_getmethods__["DEFAULT_ATTRIBUTE_FACTORY"] = lambda x: _lucenepp.AttributeFactory_DEFAULT_ATTRIBUTE_FACTORY
    if _newclass:DEFAULT_ATTRIBUTE_FACTORY = staticmethod(_lucenepp.AttributeFactory_DEFAULT_ATTRIBUTE_FACTORY)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.AttributeFactory___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.AttributeFactory___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return AttributeFactory.__cast_(obj)

AttributeFactory_swigregister = _lucenepp.AttributeFactory_swigregister
AttributeFactory_swigregister(AttributeFactory)

def AttributeFactory_DEFAULT_ATTRIBUTE_FACTORY():
  return _lucenepp.AttributeFactory_DEFAULT_ATTRIBUTE_FACTORY()
AttributeFactory_DEFAULT_ATTRIBUTE_FACTORY = _lucenepp.AttributeFactory_DEFAULT_ATTRIBUTE_FACTORY

def AttributeFactory___cast_(*args):
  return _lucenepp.AttributeFactory___cast_(*args)
AttributeFactory___cast_ = _lucenepp.AttributeFactory___cast_

class AttributeSource(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AttributeSource, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AttributeSource, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_AttributeSource(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_AttributeSource
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.AttributeSource_getClassName(self)
    def getAttributeFactory(self): return _lucenepp.AttributeSource_getAttributeFactory(self)
    def addAttribute(self, *args): return _lucenepp.AttributeSource_addAttribute(self, *args)
    def hasAttributes(self): return _lucenepp.AttributeSource_hasAttributes(self)
    def clearAttributes(self): return _lucenepp.AttributeSource_clearAttributes(self)
    def captureState(self): return _lucenepp.AttributeSource_captureState(self)
    def restoreState(self, *args): return _lucenepp.AttributeSource_restoreState(self, *args)
    def cloneAttributes(self): return _lucenepp.AttributeSource_cloneAttributes(self)
    def getAttributes(self): return _lucenepp.AttributeSource_getAttributes(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.AttributeSource___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.AttributeSource___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return AttributeSource.__cast_(obj)

    def _getAttribute(self, *args): return _lucenepp.AttributeSource__getAttribute(self, *args)
    def _hasAttribute(self, *args): return _lucenepp.AttributeSource__hasAttribute(self, *args)
    def _addAttribute(self, *args): return _lucenepp.AttributeSource__addAttribute(self, *args)
    def _getAttributeName(self, classType):
      name = str(classType)
      if not name.startswith("<class 'lucene."): raise Exception("Invalid Attribute")
      if not name.endswith("Attribute'>"): raise Exception("Invalid Attribute")
      name = name[len("<class 'lucene."):-2]
      return name
    def getAttribute(self, classType): return classType.cast_(self._getAttribute(self._getAttributeName(classType)))
    def hasAttribute(self, classType): return self._hasAttribute(self._getAttributeName(classType))
    def addAttribute(self, classType): return classType.cast_(self._addAttribute(self._getAttributeName(classType)))

AttributeSource_swigregister = _lucenepp.AttributeSource_swigregister
AttributeSource_swigregister(AttributeSource)

def AttributeSource___cast_(*args):
  return _lucenepp.AttributeSource___cast_(*args)
AttributeSource___cast_ = _lucenepp.AttributeSource___cast_

class AttributeSourceState(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AttributeSourceState, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AttributeSourceState, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_AttributeSourceState
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.AttributeSourceState_getClassName(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.AttributeSourceState___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.AttributeSourceState___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return AttributeSourceState.__cast_(obj)

    def __init__(self): 
        this = _lucenepp.new_AttributeSourceState()
        try: self.this.append(this)
        except: self.this = this
AttributeSourceState_swigregister = _lucenepp.AttributeSourceState_swigregister
AttributeSourceState_swigregister(AttributeSourceState)

def AttributeSourceState___cast_(*args):
  return _lucenepp.AttributeSourceState___cast_(*args)
AttributeSourceState___cast_ = _lucenepp.AttributeSourceState___cast_

class Collator(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Collator, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Collator, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_Collator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Collator
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Collator_getClassName(self)
    def compare(self, *args): return _lucenepp.Collator_compare(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Collator___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Collator___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Collator.__cast_(obj)

Collator_swigregister = _lucenepp.Collator_swigregister
Collator_swigregister(Collator)

def Collator___cast_(*args):
  return _lucenepp.Collator___cast_(*args)
Collator___cast_ = _lucenepp.Collator___cast_

class Version(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Version, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Version, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Version
    __del__ = lambda self : None;
    LUCENE_20 = _lucenepp.Version_LUCENE_20
    LUCENE_21 = _lucenepp.Version_LUCENE_21
    LUCENE_22 = _lucenepp.Version_LUCENE_22
    LUCENE_23 = _lucenepp.Version_LUCENE_23
    LUCENE_24 = _lucenepp.Version_LUCENE_24
    LUCENE_29 = _lucenepp.Version_LUCENE_29
    LUCENE_30 = _lucenepp.Version_LUCENE_30
    LUCENE_CURRENT = _lucenepp.Version_LUCENE_CURRENT
    __swig_getmethods__["onOrAfter"] = lambda x: _lucenepp.Version_onOrAfter
    if _newclass:onOrAfter = staticmethod(_lucenepp.Version_onOrAfter)
Version_swigregister = _lucenepp.Version_swigregister
Version_swigregister(Version)

def Version_onOrAfter(*args):
  return _lucenepp.Version_onOrAfter(*args)
Version_onOrAfter = _lucenepp.Version_onOrAfter

class InfoStream(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfoStream, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfoStream, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_InfoStream
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.InfoStream_getClassName(self)
    def __lshift__(self, *args): return _lucenepp.InfoStream___lshift__(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.InfoStream___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.InfoStream___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return InfoStream.__cast_(obj)

InfoStream_swigregister = _lucenepp.InfoStream_swigregister
InfoStream_swigregister(InfoStream)

def InfoStream___cast_(*args):
  return _lucenepp.InfoStream___cast_(*args)
InfoStream___cast_ = _lucenepp.InfoStream___cast_

class InfoStreamFile(InfoStream):
    __swig_setmethods__ = {}
    for _s in [InfoStream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfoStreamFile, name, value)
    __swig_getmethods__ = {}
    for _s in [InfoStream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfoStreamFile, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_InfoStreamFile(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_InfoStreamFile
    __del__ = lambda self : None;
    def __lshift__(self, *args): return _lucenepp.InfoStreamFile___lshift__(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.InfoStreamFile___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.InfoStreamFile___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return InfoStreamFile.__cast_(obj)

InfoStreamFile_swigregister = _lucenepp.InfoStreamFile_swigregister
InfoStreamFile_swigregister(InfoStreamFile)

def InfoStreamFile___cast_(*args):
  return _lucenepp.InfoStreamFile___cast_(*args)
InfoStreamFile___cast_ = _lucenepp.InfoStreamFile___cast_

class InfoStreamOut(InfoStream):
    __swig_setmethods__ = {}
    for _s in [InfoStream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfoStreamOut, name, value)
    __swig_getmethods__ = {}
    for _s in [InfoStream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfoStreamOut, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_InfoStreamOut
    __del__ = lambda self : None;
    def __lshift__(self, *args): return _lucenepp.InfoStreamOut___lshift__(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.InfoStreamOut___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.InfoStreamOut___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return InfoStreamOut.__cast_(obj)

    def __init__(self): 
        this = _lucenepp.new_InfoStreamOut()
        try: self.this.append(this)
        except: self.this = this
InfoStreamOut_swigregister = _lucenepp.InfoStreamOut_swigregister
InfoStreamOut_swigregister(InfoStreamOut)

def InfoStreamOut___cast_(*args):
  return _lucenepp.InfoStreamOut___cast_(*args)
InfoStreamOut___cast_ = _lucenepp.InfoStreamOut___cast_

class InfoStreamNull(InfoStream):
    __swig_setmethods__ = {}
    for _s in [InfoStream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InfoStreamNull, name, value)
    __swig_getmethods__ = {}
    for _s in [InfoStream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InfoStreamNull, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_InfoStreamNull
    __del__ = lambda self : None;
    def __lshift__(self, *args): return _lucenepp.InfoStreamNull___lshift__(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.InfoStreamNull___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.InfoStreamNull___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return InfoStreamNull.__cast_(obj)

    def __init__(self): 
        this = _lucenepp.new_InfoStreamNull()
        try: self.this.append(this)
        except: self.this = this
InfoStreamNull_swigregister = _lucenepp.InfoStreamNull_swigregister
InfoStreamNull_swigregister(InfoStreamNull)

def InfoStreamNull___cast_(*args):
  return _lucenepp.InfoStreamNull___cast_(*args)
InfoStreamNull___cast_ = _lucenepp.InfoStreamNull___cast_

class FieldCacheSanityChecker(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldCacheSanityChecker, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FieldCacheSanityChecker, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_FieldCacheSanityChecker()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_FieldCacheSanityChecker
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.FieldCacheSanityChecker_getClassName(self)
    SUBREADER = _lucenepp.FieldCacheSanityChecker_SUBREADER
    VALUEMISMATCH = _lucenepp.FieldCacheSanityChecker_VALUEMISMATCH
    EXPECTED = _lucenepp.FieldCacheSanityChecker_EXPECTED
    __swig_getmethods__["checkSanity"] = lambda x: _lucenepp.FieldCacheSanityChecker_checkSanity
    if _newclass:checkSanity = staticmethod(_lucenepp.FieldCacheSanityChecker_checkSanity)
    def check(self, *args): return _lucenepp.FieldCacheSanityChecker_check(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FieldCacheSanityChecker___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FieldCacheSanityChecker___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FieldCacheSanityChecker.__cast_(obj)

FieldCacheSanityChecker_swigregister = _lucenepp.FieldCacheSanityChecker_swigregister
FieldCacheSanityChecker_swigregister(FieldCacheSanityChecker)

def FieldCacheSanityChecker_checkSanity(*args):
  return _lucenepp.FieldCacheSanityChecker_checkSanity(*args)
FieldCacheSanityChecker_checkSanity = _lucenepp.FieldCacheSanityChecker_checkSanity

def FieldCacheSanityChecker___cast_(*args):
  return _lucenepp.FieldCacheSanityChecker___cast_(*args)
FieldCacheSanityChecker___cast_ = _lucenepp.FieldCacheSanityChecker___cast_

class Insanity(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Insanity, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Insanity, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_Insanity(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Insanity
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Insanity_getClassName(self)
    def getType(self): return _lucenepp.Insanity_getType(self)
    def getMsg(self): return _lucenepp.Insanity_getMsg(self)
    def getCacheEntries(self): return _lucenepp.Insanity_getCacheEntries(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Insanity___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Insanity___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Insanity.__cast_(obj)

Insanity_swigregister = _lucenepp.Insanity_swigregister
Insanity_swigregister(Insanity)

def Insanity___cast_(*args):
  return _lucenepp.Insanity___cast_(*args)
Insanity___cast_ = _lucenepp.Insanity___cast_


def DumpCycleCheckRefs():
  return _lucenepp.DumpCycleCheckRefs()
DumpCycleCheckRefs = _lucenepp.DumpCycleCheckRefs
class Fieldable(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Fieldable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Fieldable, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassName(self): return _lucenepp.Fieldable_getClassName(self)
    def setBoost(self, *args): return _lucenepp.Fieldable_setBoost(self, *args)
    def getBoost(self): return _lucenepp.Fieldable_getBoost(self)
    def name(self): return _lucenepp.Fieldable_name(self)
    def stringValue(self): return _lucenepp.Fieldable_stringValue(self)
    def readerValue(self): return _lucenepp.Fieldable_readerValue(self)
    def tokenStreamValue(self): return _lucenepp.Fieldable_tokenStreamValue(self)
    def isStored(self): return _lucenepp.Fieldable_isStored(self)
    def isIndexed(self): return _lucenepp.Fieldable_isIndexed(self)
    def isTokenized(self): return _lucenepp.Fieldable_isTokenized(self)
    def isTermVectorStored(self): return _lucenepp.Fieldable_isTermVectorStored(self)
    def isStoreOffsetWithTermVector(self): return _lucenepp.Fieldable_isStoreOffsetWithTermVector(self)
    def isStorePositionWithTermVector(self): return _lucenepp.Fieldable_isStorePositionWithTermVector(self)
    def isBinary(self): return _lucenepp.Fieldable_isBinary(self)
    def getOmitNorms(self): return _lucenepp.Fieldable_getOmitNorms(self)
    def setOmitNorms(self, *args): return _lucenepp.Fieldable_setOmitNorms(self, *args)
    def isLazy(self): return _lucenepp.Fieldable_isLazy(self)
    def getBinaryOffset(self): return _lucenepp.Fieldable_getBinaryOffset(self)
    def getBinaryLength(self): return _lucenepp.Fieldable_getBinaryLength(self)
    def getBinaryValue(self, *args): return _lucenepp.Fieldable_getBinaryValue(self, *args)
    def getOmitTermFreqAndPositions(self): return _lucenepp.Fieldable_getOmitTermFreqAndPositions(self)
    def setOmitTermFreqAndPositions(self, *args): return _lucenepp.Fieldable_setOmitTermFreqAndPositions(self, *args)
    def toLuceneObject__(self, *args): return _lucenepp.Fieldable_toLuceneObject__(self, *args)
    def toLuceneObject(self): return self.toLuceneObject__(self)

    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Fieldable___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Fieldable___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Fieldable.__cast_(obj)

    __swig_destroy__ = _lucenepp.delete_Fieldable
    __del__ = lambda self : None;
Fieldable_swigregister = _lucenepp.Fieldable_swigregister
Fieldable_swigregister(Fieldable)

def Fieldable___cast_(*args):
  return _lucenepp.Fieldable___cast_(*args)
Fieldable___cast_ = _lucenepp.Fieldable___cast_

class AbstractField(Fieldable,LuceneObject):
    __swig_setmethods__ = {}
    for _s in [Fieldable,LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AbstractField, name, value)
    __swig_getmethods__ = {}
    for _s in [Fieldable,LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AbstractField, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    STORE_YES = _lucenepp.AbstractField_STORE_YES
    STORE_NO = _lucenepp.AbstractField_STORE_NO
    INDEX_NO = _lucenepp.AbstractField_INDEX_NO
    INDEX_ANALYZED = _lucenepp.AbstractField_INDEX_ANALYZED
    INDEX_NOT_ANALYZED = _lucenepp.AbstractField_INDEX_NOT_ANALYZED
    INDEX_NOT_ANALYZED_NO_NORMS = _lucenepp.AbstractField_INDEX_NOT_ANALYZED_NO_NORMS
    INDEX_ANALYZED_NO_NORMS = _lucenepp.AbstractField_INDEX_ANALYZED_NO_NORMS
    TERM_VECTOR_NO = _lucenepp.AbstractField_TERM_VECTOR_NO
    TERM_VECTOR_YES = _lucenepp.AbstractField_TERM_VECTOR_YES
    TERM_VECTOR_WITH_POSITIONS = _lucenepp.AbstractField_TERM_VECTOR_WITH_POSITIONS
    TERM_VECTOR_WITH_OFFSETS = _lucenepp.AbstractField_TERM_VECTOR_WITH_OFFSETS
    TERM_VECTOR_WITH_POSITIONS_OFFSETS = _lucenepp.AbstractField_TERM_VECTOR_WITH_POSITIONS_OFFSETS
    __swig_destroy__ = _lucenepp.delete_AbstractField
    __del__ = lambda self : None;
    def getBinaryValue(self, *args): return _lucenepp.AbstractField_getBinaryValue(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.AbstractField___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.AbstractField___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return AbstractField.__cast_(obj)

AbstractField_swigregister = _lucenepp.AbstractField_swigregister
AbstractField_swigregister(AbstractField)

def AbstractField___cast_(*args):
  return _lucenepp.AbstractField___cast_(*args)
AbstractField___cast_ = _lucenepp.AbstractField___cast_

class Field(AbstractField):
    __swig_setmethods__ = {}
    for _s in [AbstractField]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Field, name, value)
    __swig_getmethods__ = {}
    for _s in [AbstractField]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Field, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_Field(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Field
    __del__ = lambda self : None;
    __swig_getmethods__["isIndexed"] = lambda x: _lucenepp.Field_isIndexed
    if _newclass:isIndexed = staticmethod(_lucenepp.Field_isIndexed)
    __swig_getmethods__["isAnalyzed"] = lambda x: _lucenepp.Field_isAnalyzed
    if _newclass:isAnalyzed = staticmethod(_lucenepp.Field_isAnalyzed)
    __swig_getmethods__["omitNorms"] = lambda x: _lucenepp.Field_omitNorms
    if _newclass:omitNorms = staticmethod(_lucenepp.Field_omitNorms)
    __swig_getmethods__["toIndex"] = lambda x: _lucenepp.Field_toIndex
    if _newclass:toIndex = staticmethod(_lucenepp.Field_toIndex)
    __swig_getmethods__["isStored"] = lambda x: _lucenepp.Field_isStored
    if _newclass:isStored = staticmethod(_lucenepp.Field_isStored)
    __swig_getmethods__["withPositions"] = lambda x: _lucenepp.Field_withPositions
    if _newclass:withPositions = staticmethod(_lucenepp.Field_withPositions)
    __swig_getmethods__["withOffsets"] = lambda x: _lucenepp.Field_withOffsets
    if _newclass:withOffsets = staticmethod(_lucenepp.Field_withOffsets)
    __swig_getmethods__["toTermVector"] = lambda x: _lucenepp.Field_toTermVector
    if _newclass:toTermVector = staticmethod(_lucenepp.Field_toTermVector)
    def setValue(self, *args): return _lucenepp.Field_setValue(self, *args)
    def setTokenStream(self, *args): return _lucenepp.Field_setTokenStream(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Field___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Field___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Field.__cast_(obj)

Field_swigregister = _lucenepp.Field_swigregister
Field_swigregister(Field)

def Field_isIndexed(*args):
  return _lucenepp.Field_isIndexed(*args)
Field_isIndexed = _lucenepp.Field_isIndexed

def Field_isAnalyzed(*args):
  return _lucenepp.Field_isAnalyzed(*args)
Field_isAnalyzed = _lucenepp.Field_isAnalyzed

def Field_omitNorms(*args):
  return _lucenepp.Field_omitNorms(*args)
Field_omitNorms = _lucenepp.Field_omitNorms

def Field_toIndex(*args):
  return _lucenepp.Field_toIndex(*args)
Field_toIndex = _lucenepp.Field_toIndex

def Field_isStored(*args):
  return _lucenepp.Field_isStored(*args)
Field_isStored = _lucenepp.Field_isStored

def Field_withPositions(*args):
  return _lucenepp.Field_withPositions(*args)
Field_withPositions = _lucenepp.Field_withPositions

def Field_withOffsets(*args):
  return _lucenepp.Field_withOffsets(*args)
Field_withOffsets = _lucenepp.Field_withOffsets

def Field_toTermVector(*args):
  return _lucenepp.Field_toTermVector(*args)
Field_toTermVector = _lucenepp.Field_toTermVector

def Field___cast_(*args):
  return _lucenepp.Field___cast_(*args)
Field___cast_ = _lucenepp.Field___cast_

class DateField(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DateField, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DateField, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_DateField
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.DateField_getClassName(self)
    __swig_getmethods__["MIN_DATE_STRING"] = lambda x: _lucenepp.DateField_MIN_DATE_STRING
    if _newclass:MIN_DATE_STRING = staticmethod(_lucenepp.DateField_MIN_DATE_STRING)
    __swig_getmethods__["MAX_DATE_STRING"] = lambda x: _lucenepp.DateField_MAX_DATE_STRING
    if _newclass:MAX_DATE_STRING = staticmethod(_lucenepp.DateField_MAX_DATE_STRING)
    __swig_getmethods__["timeToString"] = lambda x: _lucenepp.DateField_timeToString
    if _newclass:timeToString = staticmethod(_lucenepp.DateField_timeToString)
    __swig_getmethods__["stringToTime"] = lambda x: _lucenepp.DateField_stringToTime
    if _newclass:stringToTime = staticmethod(_lucenepp.DateField_stringToTime)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.DateField___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.DateField___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return DateField.__cast_(obj)

DateField_swigregister = _lucenepp.DateField_swigregister
DateField_swigregister(DateField)

def DateField_MIN_DATE_STRING():
  return _lucenepp.DateField_MIN_DATE_STRING()
DateField_MIN_DATE_STRING = _lucenepp.DateField_MIN_DATE_STRING

def DateField_MAX_DATE_STRING():
  return _lucenepp.DateField_MAX_DATE_STRING()
DateField_MAX_DATE_STRING = _lucenepp.DateField_MAX_DATE_STRING

def DateField_timeToString(*args):
  return _lucenepp.DateField_timeToString(*args)
DateField_timeToString = _lucenepp.DateField_timeToString

def DateField_stringToTime(*args):
  return _lucenepp.DateField_stringToTime(*args)
DateField_stringToTime = _lucenepp.DateField_stringToTime

def DateField___cast_(*args):
  return _lucenepp.DateField___cast_(*args)
DateField___cast_ = _lucenepp.DateField___cast_

class DateTools(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DateTools, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DateTools, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_DateTools
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.DateTools_getClassName(self)
    RESOLUTION_NULL = _lucenepp.DateTools_RESOLUTION_NULL
    RESOLUTION_YEAR = _lucenepp.DateTools_RESOLUTION_YEAR
    RESOLUTION_MONTH = _lucenepp.DateTools_RESOLUTION_MONTH
    RESOLUTION_DAY = _lucenepp.DateTools_RESOLUTION_DAY
    RESOLUTION_HOUR = _lucenepp.DateTools_RESOLUTION_HOUR
    RESOLUTION_MINUTE = _lucenepp.DateTools_RESOLUTION_MINUTE
    RESOLUTION_SECOND = _lucenepp.DateTools_RESOLUTION_SECOND
    RESOLUTION_MILLISECOND = _lucenepp.DateTools_RESOLUTION_MILLISECOND
    DATEORDER_LOCALE = _lucenepp.DateTools_DATEORDER_LOCALE
    DATEORDER_YMD = _lucenepp.DateTools_DATEORDER_YMD
    DATEORDER_DMY = _lucenepp.DateTools_DATEORDER_DMY
    DATEORDER_MDY = _lucenepp.DateTools_DATEORDER_MDY
    __swig_getmethods__["timeToString"] = lambda x: _lucenepp.DateTools_timeToString
    if _newclass:timeToString = staticmethod(_lucenepp.DateTools_timeToString)
    __swig_getmethods__["stringToTime"] = lambda x: _lucenepp.DateTools_stringToTime
    if _newclass:stringToTime = staticmethod(_lucenepp.DateTools_stringToTime)
    __swig_getmethods__["round"] = lambda x: _lucenepp.DateTools_round
    if _newclass:round = staticmethod(_lucenepp.DateTools_round)
    __swig_getmethods__["setDateOrder"] = lambda x: _lucenepp.DateTools_setDateOrder
    if _newclass:setDateOrder = staticmethod(_lucenepp.DateTools_setDateOrder)
    __swig_getmethods__["getDateOrder"] = lambda x: _lucenepp.DateTools_getDateOrder
    if _newclass:getDateOrder = staticmethod(_lucenepp.DateTools_getDateOrder)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.DateTools___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.DateTools___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return DateTools.__cast_(obj)

DateTools_swigregister = _lucenepp.DateTools_swigregister
DateTools_swigregister(DateTools)

def DateTools_timeToString(*args):
  return _lucenepp.DateTools_timeToString(*args)
DateTools_timeToString = _lucenepp.DateTools_timeToString

def DateTools_stringToTime(*args):
  return _lucenepp.DateTools_stringToTime(*args)
DateTools_stringToTime = _lucenepp.DateTools_stringToTime

def DateTools_round(*args):
  return _lucenepp.DateTools_round(*args)
DateTools_round = _lucenepp.DateTools_round

def DateTools_setDateOrder(*args):
  return _lucenepp.DateTools_setDateOrder(*args)
DateTools_setDateOrder = _lucenepp.DateTools_setDateOrder

def DateTools_getDateOrder(*args):
  return _lucenepp.DateTools_getDateOrder(*args)
DateTools_getDateOrder = _lucenepp.DateTools_getDateOrder

def DateTools___cast_(*args):
  return _lucenepp.DateTools___cast_(*args)
DateTools___cast_ = _lucenepp.DateTools___cast_

class Document(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Document, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Document, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_Document()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Document
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Document_getClassName(self)
    def setBoost(self, *args): return _lucenepp.Document_setBoost(self, *args)
    def getBoost(self): return _lucenepp.Document_getBoost(self)
    def add(self, *args): return _lucenepp.Document_add(self, *args)
    def removeField(self, *args): return _lucenepp.Document_removeField(self, *args)
    def removeFields(self, *args): return _lucenepp.Document_removeFields(self, *args)
    def getField(self, *args): return _lucenepp.Document_getField(self, *args)
    def getFieldable(self, *args): return _lucenepp.Document_getFieldable(self, *args)
    def get(self, *args): return _lucenepp.Document_get(self, *args)
    def getFields(self, *args): return _lucenepp.Document_getFields(self, *args)
    def getFieldables(self, *args): return _lucenepp.Document_getFieldables(self, *args)
    def getValues(self, *args): return _lucenepp.Document_getValues(self, *args)
    def getBinaryValues(self, *args): return _lucenepp.Document_getBinaryValues(self, *args)
    def getBinaryValue(self, *args): return _lucenepp.Document_getBinaryValue(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Document___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Document___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Document.__cast_(obj)

    def __getitem__(self, name): return self.get(name)

Document_swigregister = _lucenepp.Document_swigregister
Document_swigregister(Document)

def Document___cast_(*args):
  return _lucenepp.Document___cast_(*args)
Document___cast_ = _lucenepp.Document___cast_

class FieldSelector(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldSelector, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FieldSelector, name)
    __repr__ = _swig_repr
    def __init__(self): 
        if self.__class__ == FieldSelector:
            _self = None
        else:
            _self = self
        this = _lucenepp.new_FieldSelector(_self, )
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_FieldSelector
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.FieldSelector_getClassName(self)
    SELECTOR_NULL = _lucenepp.FieldSelector_SELECTOR_NULL
    SELECTOR_LOAD = _lucenepp.FieldSelector_SELECTOR_LOAD
    SELECTOR_LAZY_LOAD = _lucenepp.FieldSelector_SELECTOR_LAZY_LOAD
    SELECTOR_NO_LOAD = _lucenepp.FieldSelector_SELECTOR_NO_LOAD
    SELECTOR_LOAD_AND_BREAK = _lucenepp.FieldSelector_SELECTOR_LOAD_AND_BREAK
    SELECTOR_SIZE = _lucenepp.FieldSelector_SELECTOR_SIZE
    SELECTOR_SIZE_AND_BREAK = _lucenepp.FieldSelector_SELECTOR_SIZE_AND_BREAK
    def accept(self, *args): return _lucenepp.FieldSelector_accept(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FieldSelector___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FieldSelector___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FieldSelector.__cast_(obj)

    def __disown__(self):
        self.this.disown()
        _lucenepp.disown_FieldSelector(self)
        return weakref_proxy(self)
FieldSelector_swigregister = _lucenepp.FieldSelector_swigregister
FieldSelector_swigregister(FieldSelector)

def FieldSelector___cast_(*args):
  return _lucenepp.FieldSelector___cast_(*args)
FieldSelector___cast_ = _lucenepp.FieldSelector___cast_

class NumericField(AbstractField):
    __swig_setmethods__ = {}
    for _s in [AbstractField]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericField, name, value)
    __swig_getmethods__ = {}
    for _s in [AbstractField]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericField, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_NumericField(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_NumericField
    __del__ = lambda self : None;
    def getNumericValue(self): return _lucenepp.NumericField_getNumericValue(self)
    def setLongValue(self, *args): return _lucenepp.NumericField_setLongValue(self, *args)
    def setIntValue(self, *args): return _lucenepp.NumericField_setIntValue(self, *args)
    def setDoubleValue(self, *args): return _lucenepp.NumericField_setDoubleValue(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.NumericField___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.NumericField___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return NumericField.__cast_(obj)

NumericField_swigregister = _lucenepp.NumericField_swigregister
NumericField_swigregister(NumericField)

def NumericField___cast_(*args):
  return _lucenepp.NumericField___cast_(*args)
NumericField___cast_ = _lucenepp.NumericField___cast_

class TokenStream(AttributeSource):
    __swig_setmethods__ = {}
    for _s in [AttributeSource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TokenStream, name, value)
    __swig_getmethods__ = {}
    for _s in [AttributeSource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TokenStream, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TokenStream
    __del__ = lambda self : None;
    def incrementToken(self): return _lucenepp.TokenStream_incrementToken(self)
    def end(self): return _lucenepp.TokenStream_end(self)
    def reset(self): return _lucenepp.TokenStream_reset(self)
    def close(self): return _lucenepp.TokenStream_close(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TokenStream___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TokenStream___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TokenStream.__cast_(obj)

TokenStream_swigregister = _lucenepp.TokenStream_swigregister
TokenStream_swigregister(TokenStream)

def TokenStream___cast_(*args):
  return _lucenepp.TokenStream___cast_(*args)
TokenStream___cast_ = _lucenepp.TokenStream___cast_

class Token(Attribute):
    __swig_setmethods__ = {}
    for _s in [Attribute]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Token, name, value)
    __swig_getmethods__ = {}
    for _s in [Attribute]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Token, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_Token(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Token
    __del__ = lambda self : None;
    __swig_getmethods__["DEFAULT_TYPE"] = lambda x: _lucenepp.Token_DEFAULT_TYPE
    if _newclass:DEFAULT_TYPE = staticmethod(_lucenepp.Token_DEFAULT_TYPE)
    def setPositionIncrement(self, *args): return _lucenepp.Token_setPositionIncrement(self, *args)
    def getPositionIncrement(self): return _lucenepp.Token_getPositionIncrement(self)
    def term(self): return _lucenepp.Token_term(self)
    def setTermBuffer(self, *args): return _lucenepp.Token_setTermBuffer(self, *args)
    def termBuffer(self): return _lucenepp.Token_termBuffer(self)
    def resizeTermBuffer(self, *args): return _lucenepp.Token_resizeTermBuffer(self, *args)
    def termLength(self): return _lucenepp.Token_termLength(self)
    def setTermLength(self, *args): return _lucenepp.Token_setTermLength(self, *args)
    def startOffset(self): return _lucenepp.Token_startOffset(self)
    def setStartOffset(self, *args): return _lucenepp.Token_setStartOffset(self, *args)
    def endOffset(self): return _lucenepp.Token_endOffset(self)
    def setEndOffset(self, *args): return _lucenepp.Token_setEndOffset(self, *args)
    def setOffset(self, *args): return _lucenepp.Token_setOffset(self, *args)
    def type(self): return _lucenepp.Token_type(self)
    def setType(self, *args): return _lucenepp.Token_setType(self, *args)
    def getFlags(self): return _lucenepp.Token_getFlags(self)
    def setFlags(self, *args): return _lucenepp.Token_setFlags(self, *args)
    def getPayload(self): return _lucenepp.Token_getPayload(self)
    def setPayload(self, *args): return _lucenepp.Token_setPayload(self, *args)
    def reinit(self, *args): return _lucenepp.Token_reinit(self, *args)
    __swig_getmethods__["TOKEN_ATTRIBUTE_FACTORY"] = lambda x: _lucenepp.Token_TOKEN_ATTRIBUTE_FACTORY
    if _newclass:TOKEN_ATTRIBUTE_FACTORY = staticmethod(_lucenepp.Token_TOKEN_ATTRIBUTE_FACTORY)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Token___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Token___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Token.__cast_(obj)

Token_swigregister = _lucenepp.Token_swigregister
Token_swigregister(Token)

def Token_DEFAULT_TYPE():
  return _lucenepp.Token_DEFAULT_TYPE()
Token_DEFAULT_TYPE = _lucenepp.Token_DEFAULT_TYPE

def Token_TOKEN_ATTRIBUTE_FACTORY():
  return _lucenepp.Token_TOKEN_ATTRIBUTE_FACTORY()
Token_TOKEN_ATTRIBUTE_FACTORY = _lucenepp.Token_TOKEN_ATTRIBUTE_FACTORY

def Token___cast_(*args):
  return _lucenepp.Token___cast_(*args)
Token___cast_ = _lucenepp.Token___cast_

class TokenAttributeFactory(AttributeFactory):
    __swig_setmethods__ = {}
    for _s in [AttributeFactory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TokenAttributeFactory, name, value)
    __swig_getmethods__ = {}
    for _s in [AttributeFactory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TokenAttributeFactory, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_TokenAttributeFactory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_TokenAttributeFactory
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TokenAttributeFactory___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TokenAttributeFactory___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TokenAttributeFactory.__cast_(obj)

TokenAttributeFactory_swigregister = _lucenepp.TokenAttributeFactory_swigregister
TokenAttributeFactory_swigregister(TokenAttributeFactory)

def TokenAttributeFactory___cast_(*args):
  return _lucenepp.TokenAttributeFactory___cast_(*args)
TokenAttributeFactory___cast_ = _lucenepp.TokenAttributeFactory___cast_

class TokenFilter(TokenStream):
    __swig_setmethods__ = {}
    for _s in [TokenStream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TokenFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [TokenStream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TokenFilter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TokenFilter
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TokenFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TokenFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TokenFilter.__cast_(obj)

TokenFilter_swigregister = _lucenepp.TokenFilter_swigregister
TokenFilter_swigregister(TokenFilter)

def TokenFilter___cast_(*args):
  return _lucenepp.TokenFilter___cast_(*args)
TokenFilter___cast_ = _lucenepp.TokenFilter___cast_

class Tokenizer(TokenStream):
    __swig_setmethods__ = {}
    for _s in [TokenStream]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Tokenizer, name, value)
    __swig_getmethods__ = {}
    for _s in [TokenStream]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Tokenizer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Tokenizer
    __del__ = lambda self : None;
    def correctOffset(self, *args): return _lucenepp.Tokenizer_correctOffset(self, *args)
    def reset(self, *args): return _lucenepp.Tokenizer_reset(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Tokenizer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Tokenizer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Tokenizer.__cast_(obj)

Tokenizer_swigregister = _lucenepp.Tokenizer_swigregister
Tokenizer_swigregister(Tokenizer)

def Tokenizer___cast_(*args):
  return _lucenepp.Tokenizer___cast_(*args)
Tokenizer___cast_ = _lucenepp.Tokenizer___cast_

class Analyzer(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Analyzer, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Analyzer, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Analyzer
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Analyzer_getClassName(self)
    def tokenStream(self, *args): return _lucenepp.Analyzer_tokenStream(self, *args)
    def reusableTokenStream(self, *args): return _lucenepp.Analyzer_reusableTokenStream(self, *args)
    def getPositionIncrementGap(self, *args): return _lucenepp.Analyzer_getPositionIncrementGap(self, *args)
    def getOffsetGap(self, *args): return _lucenepp.Analyzer_getOffsetGap(self, *args)
    def close(self): return _lucenepp.Analyzer_close(self)
    def getPreviousTokenStream(self): return _lucenepp.Analyzer_getPreviousTokenStream(self)
    def setPreviousTokenStream(self, *args): return _lucenepp.Analyzer_setPreviousTokenStream(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Analyzer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Analyzer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Analyzer.__cast_(obj)

    def __init__(self): 
        if self.__class__ == Analyzer:
            _self = None
        else:
            _self = self
        this = _lucenepp.new_Analyzer(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _lucenepp.disown_Analyzer(self)
        return weakref_proxy(self)
Analyzer_swigregister = _lucenepp.Analyzer_swigregister
Analyzer_swigregister(Analyzer)

def Analyzer___cast_(*args):
  return _lucenepp.Analyzer___cast_(*args)
Analyzer___cast_ = _lucenepp.Analyzer___cast_

class ASCIIFoldingFilter(TokenFilter):
    __swig_setmethods__ = {}
    for _s in [TokenFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ASCIIFoldingFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [TokenFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ASCIIFoldingFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_ASCIIFoldingFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_ASCIIFoldingFilter
    __del__ = lambda self : None;
    def foldToASCII(self, *args): return _lucenepp.ASCIIFoldingFilter_foldToASCII(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.ASCIIFoldingFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.ASCIIFoldingFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return ASCIIFoldingFilter.__cast_(obj)

ASCIIFoldingFilter_swigregister = _lucenepp.ASCIIFoldingFilter_swigregister
ASCIIFoldingFilter_swigregister(ASCIIFoldingFilter)

def ASCIIFoldingFilter___cast_(*args):
  return _lucenepp.ASCIIFoldingFilter___cast_(*args)
ASCIIFoldingFilter___cast_ = _lucenepp.ASCIIFoldingFilter___cast_

class CharFilter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CharFilter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CharFilter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_CharFilter
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.CharFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.CharFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return CharFilter.__cast_(obj)

CharFilter_swigregister = _lucenepp.CharFilter_swigregister
CharFilter_swigregister(CharFilter)

def CharFilter___cast_(*args):
  return _lucenepp.CharFilter___cast_(*args)
CharFilter___cast_ = _lucenepp.CharFilter___cast_

class CharTokenizer(Tokenizer):
    __swig_setmethods__ = {}
    for _s in [Tokenizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CharTokenizer, name, value)
    __swig_getmethods__ = {}
    for _s in [Tokenizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CharTokenizer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_CharTokenizer
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.CharTokenizer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.CharTokenizer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return CharTokenizer.__cast_(obj)

CharTokenizer_swigregister = _lucenepp.CharTokenizer_swigregister
CharTokenizer_swigregister(CharTokenizer)

def CharTokenizer___cast_(*args):
  return _lucenepp.CharTokenizer___cast_(*args)
CharTokenizer___cast_ = _lucenepp.CharTokenizer___cast_

class BaseCharFilter(CharFilter):
    __swig_setmethods__ = {}
    for _s in [CharFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BaseCharFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [CharFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BaseCharFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_BaseCharFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_BaseCharFilter
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.BaseCharFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.BaseCharFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return BaseCharFilter.__cast_(obj)

BaseCharFilter_swigregister = _lucenepp.BaseCharFilter_swigregister
BaseCharFilter_swigregister(BaseCharFilter)

def BaseCharFilter___cast_(*args):
  return _lucenepp.BaseCharFilter___cast_(*args)
BaseCharFilter___cast_ = _lucenepp.BaseCharFilter___cast_

class FlagsAttribute(Attribute):
    __swig_setmethods__ = {}
    for _s in [Attribute]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FlagsAttribute, name, value)
    __swig_getmethods__ = {}
    for _s in [Attribute]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FlagsAttribute, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_FlagsAttribute()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_FlagsAttribute
    __del__ = lambda self : None;
    def getFlags(self): return _lucenepp.FlagsAttribute_getFlags(self)
    def setFlags(self, *args): return _lucenepp.FlagsAttribute_setFlags(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FlagsAttribute___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FlagsAttribute___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FlagsAttribute.__cast_(obj)

FlagsAttribute_swigregister = _lucenepp.FlagsAttribute_swigregister
FlagsAttribute_swigregister(FlagsAttribute)

def FlagsAttribute___cast_(*args):
  return _lucenepp.FlagsAttribute___cast_(*args)
FlagsAttribute___cast_ = _lucenepp.FlagsAttribute___cast_

class CachingTokenFilter(TokenFilter):
    __swig_setmethods__ = {}
    for _s in [TokenFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CachingTokenFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [TokenFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CachingTokenFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_CachingTokenFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_CachingTokenFilter
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.CachingTokenFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.CachingTokenFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return CachingTokenFilter.__cast_(obj)

CachingTokenFilter_swigregister = _lucenepp.CachingTokenFilter_swigregister
CachingTokenFilter_swigregister(CachingTokenFilter)

def CachingTokenFilter___cast_(*args):
  return _lucenepp.CachingTokenFilter___cast_(*args)
CachingTokenFilter___cast_ = _lucenepp.CachingTokenFilter___cast_

class ISOLatin1AccentFilter(TokenFilter):
    __swig_setmethods__ = {}
    for _s in [TokenFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ISOLatin1AccentFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [TokenFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ISOLatin1AccentFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_ISOLatin1AccentFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_ISOLatin1AccentFilter
    __del__ = lambda self : None;
    def removeAccents(self, *args): return _lucenepp.ISOLatin1AccentFilter_removeAccents(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.ISOLatin1AccentFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.ISOLatin1AccentFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return ISOLatin1AccentFilter.__cast_(obj)

ISOLatin1AccentFilter_swigregister = _lucenepp.ISOLatin1AccentFilter_swigregister
ISOLatin1AccentFilter_swigregister(ISOLatin1AccentFilter)

def ISOLatin1AccentFilter___cast_(*args):
  return _lucenepp.ISOLatin1AccentFilter___cast_(*args)
ISOLatin1AccentFilter___cast_ = _lucenepp.ISOLatin1AccentFilter___cast_

class KeywordTokenizer(Tokenizer):
    __swig_setmethods__ = {}
    for _s in [Tokenizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KeywordTokenizer, name, value)
    __swig_getmethods__ = {}
    for _s in [Tokenizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KeywordTokenizer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_KeywordTokenizer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_KeywordTokenizer
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.KeywordTokenizer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.KeywordTokenizer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return KeywordTokenizer.__cast_(obj)

KeywordTokenizer_swigregister = _lucenepp.KeywordTokenizer_swigregister
KeywordTokenizer_swigregister(KeywordTokenizer)

def KeywordTokenizer___cast_(*args):
  return _lucenepp.KeywordTokenizer___cast_(*args)
KeywordTokenizer___cast_ = _lucenepp.KeywordTokenizer___cast_

class LengthFilter(TokenFilter):
    __swig_setmethods__ = {}
    for _s in [TokenFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LengthFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [TokenFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LengthFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_LengthFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_LengthFilter
    __del__ = lambda self : None;
    __swig_setmethods__["min"] = _lucenepp.LengthFilter_min_set
    __swig_getmethods__["min"] = _lucenepp.LengthFilter_min_get
    if _newclass:min = _swig_property(_lucenepp.LengthFilter_min_get, _lucenepp.LengthFilter_min_set)
    __swig_setmethods__["max"] = _lucenepp.LengthFilter_max_set
    __swig_getmethods__["max"] = _lucenepp.LengthFilter_max_get
    if _newclass:max = _swig_property(_lucenepp.LengthFilter_max_get, _lucenepp.LengthFilter_max_set)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.LengthFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.LengthFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return LengthFilter.__cast_(obj)

LengthFilter_swigregister = _lucenepp.LengthFilter_swigregister
LengthFilter_swigregister(LengthFilter)

def LengthFilter___cast_(*args):
  return _lucenepp.LengthFilter___cast_(*args)
LengthFilter___cast_ = _lucenepp.LengthFilter___cast_

class LetterTokenizer(CharTokenizer):
    __swig_setmethods__ = {}
    for _s in [CharTokenizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LetterTokenizer, name, value)
    __swig_getmethods__ = {}
    for _s in [CharTokenizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LetterTokenizer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_LetterTokenizer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_LetterTokenizer
    __del__ = lambda self : None;
    def isTokenChar(self, *args): return _lucenepp.LetterTokenizer_isTokenChar(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.LetterTokenizer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.LetterTokenizer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return LetterTokenizer.__cast_(obj)

LetterTokenizer_swigregister = _lucenepp.LetterTokenizer_swigregister
LetterTokenizer_swigregister(LetterTokenizer)

def LetterTokenizer___cast_(*args):
  return _lucenepp.LetterTokenizer___cast_(*args)
LetterTokenizer___cast_ = _lucenepp.LetterTokenizer___cast_

class LowerCaseFilter(TokenFilter):
    __swig_setmethods__ = {}
    for _s in [TokenFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LowerCaseFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [TokenFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LowerCaseFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_LowerCaseFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_LowerCaseFilter
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.LowerCaseFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.LowerCaseFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return LowerCaseFilter.__cast_(obj)

LowerCaseFilter_swigregister = _lucenepp.LowerCaseFilter_swigregister
LowerCaseFilter_swigregister(LowerCaseFilter)

def LowerCaseFilter___cast_(*args):
  return _lucenepp.LowerCaseFilter___cast_(*args)
LowerCaseFilter___cast_ = _lucenepp.LowerCaseFilter___cast_

class LowerCaseTokenizer(LetterTokenizer):
    __swig_setmethods__ = {}
    for _s in [LetterTokenizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LowerCaseTokenizer, name, value)
    __swig_getmethods__ = {}
    for _s in [LetterTokenizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LowerCaseTokenizer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_LowerCaseTokenizer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_LowerCaseTokenizer
    __del__ = lambda self : None;
    def normalize(self, *args): return _lucenepp.LowerCaseTokenizer_normalize(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.LowerCaseTokenizer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.LowerCaseTokenizer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return LowerCaseTokenizer.__cast_(obj)

LowerCaseTokenizer_swigregister = _lucenepp.LowerCaseTokenizer_swigregister
LowerCaseTokenizer_swigregister(LowerCaseTokenizer)

def LowerCaseTokenizer___cast_(*args):
  return _lucenepp.LowerCaseTokenizer___cast_(*args)
LowerCaseTokenizer___cast_ = _lucenepp.LowerCaseTokenizer___cast_

class MappingCharFilter(BaseCharFilter):
    __swig_setmethods__ = {}
    for _s in [BaseCharFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MappingCharFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [BaseCharFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MappingCharFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_MappingCharFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_MappingCharFilter
    __del__ = lambda self : None;
    def read(self, *args): return _lucenepp.MappingCharFilter_read(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.MappingCharFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.MappingCharFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return MappingCharFilter.__cast_(obj)

MappingCharFilter_swigregister = _lucenepp.MappingCharFilter_swigregister
MappingCharFilter_swigregister(MappingCharFilter)

def MappingCharFilter___cast_(*args):
  return _lucenepp.MappingCharFilter___cast_(*args)
MappingCharFilter___cast_ = _lucenepp.MappingCharFilter___cast_

class OffsetAttribute(Attribute):
    __swig_setmethods__ = {}
    for _s in [Attribute]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffsetAttribute, name, value)
    __swig_getmethods__ = {}
    for _s in [Attribute]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OffsetAttribute, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_OffsetAttribute()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_OffsetAttribute
    __del__ = lambda self : None;
    def startOffset(self): return _lucenepp.OffsetAttribute_startOffset(self)
    def setOffset(self, *args): return _lucenepp.OffsetAttribute_setOffset(self, *args)
    def endOffset(self): return _lucenepp.OffsetAttribute_endOffset(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.OffsetAttribute___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.OffsetAttribute___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return OffsetAttribute.__cast_(obj)

OffsetAttribute_swigregister = _lucenepp.OffsetAttribute_swigregister
OffsetAttribute_swigregister(OffsetAttribute)

def OffsetAttribute___cast_(*args):
  return _lucenepp.OffsetAttribute___cast_(*args)
OffsetAttribute___cast_ = _lucenepp.OffsetAttribute___cast_

class PayloadAttribute(Attribute):
    __swig_setmethods__ = {}
    for _s in [Attribute]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadAttribute, name, value)
    __swig_getmethods__ = {}
    for _s in [Attribute]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadAttribute, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_PayloadAttribute(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PayloadAttribute
    __del__ = lambda self : None;
    def getPayload(self): return _lucenepp.PayloadAttribute_getPayload(self)
    def setPayload(self, *args): return _lucenepp.PayloadAttribute_setPayload(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PayloadAttribute___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PayloadAttribute___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PayloadAttribute.__cast_(obj)

PayloadAttribute_swigregister = _lucenepp.PayloadAttribute_swigregister
PayloadAttribute_swigregister(PayloadAttribute)

def PayloadAttribute___cast_(*args):
  return _lucenepp.PayloadAttribute___cast_(*args)
PayloadAttribute___cast_ = _lucenepp.PayloadAttribute___cast_

class PerFieldAnalyzerWrapper(Analyzer):
    __swig_setmethods__ = {}
    for _s in [Analyzer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PerFieldAnalyzerWrapper, name, value)
    __swig_getmethods__ = {}
    for _s in [Analyzer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PerFieldAnalyzerWrapper, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_PerFieldAnalyzerWrapper(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PerFieldAnalyzerWrapper
    __del__ = lambda self : None;
    def addAnalyzer(self, *args): return _lucenepp.PerFieldAnalyzerWrapper_addAnalyzer(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PerFieldAnalyzerWrapper___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PerFieldAnalyzerWrapper___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PerFieldAnalyzerWrapper.__cast_(obj)

PerFieldAnalyzerWrapper_swigregister = _lucenepp.PerFieldAnalyzerWrapper_swigregister
PerFieldAnalyzerWrapper_swigregister(PerFieldAnalyzerWrapper)

def PerFieldAnalyzerWrapper___cast_(*args):
  return _lucenepp.PerFieldAnalyzerWrapper___cast_(*args)
PerFieldAnalyzerWrapper___cast_ = _lucenepp.PerFieldAnalyzerWrapper___cast_

class PositionIncrementAttribute(Attribute):
    __swig_setmethods__ = {}
    for _s in [Attribute]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PositionIncrementAttribute, name, value)
    __swig_getmethods__ = {}
    for _s in [Attribute]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PositionIncrementAttribute, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_PositionIncrementAttribute()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PositionIncrementAttribute
    __del__ = lambda self : None;
    def setPositionIncrement(self, *args): return _lucenepp.PositionIncrementAttribute_setPositionIncrement(self, *args)
    def getPositionIncrement(self): return _lucenepp.PositionIncrementAttribute_getPositionIncrement(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PositionIncrementAttribute___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PositionIncrementAttribute___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PositionIncrementAttribute.__cast_(obj)

PositionIncrementAttribute_swigregister = _lucenepp.PositionIncrementAttribute_swigregister
PositionIncrementAttribute_swigregister(PositionIncrementAttribute)

def PositionIncrementAttribute___cast_(*args):
  return _lucenepp.PositionIncrementAttribute___cast_(*args)
PositionIncrementAttribute___cast_ = _lucenepp.PositionIncrementAttribute___cast_

class SimpleAnalyzer(Analyzer):
    __swig_setmethods__ = {}
    for _s in [Analyzer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleAnalyzer, name, value)
    __swig_getmethods__ = {}
    for _s in [Analyzer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleAnalyzer, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SimpleAnalyzer
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SimpleAnalyzer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SimpleAnalyzer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SimpleAnalyzer.__cast_(obj)

    def __init__(self): 
        this = _lucenepp.new_SimpleAnalyzer()
        try: self.this.append(this)
        except: self.this = this
SimpleAnalyzer_swigregister = _lucenepp.SimpleAnalyzer_swigregister
SimpleAnalyzer_swigregister(SimpleAnalyzer)

def SimpleAnalyzer___cast_(*args):
  return _lucenepp.SimpleAnalyzer___cast_(*args)
SimpleAnalyzer___cast_ = _lucenepp.SimpleAnalyzer___cast_

class StandardAnalyzer(Analyzer):
    __swig_setmethods__ = {}
    for _s in [Analyzer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StandardAnalyzer, name, value)
    __swig_getmethods__ = {}
    for _s in [Analyzer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StandardAnalyzer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_StandardAnalyzer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_StandardAnalyzer
    __del__ = lambda self : None;
    def setMaxTokenLength(self, *args): return _lucenepp.StandardAnalyzer_setMaxTokenLength(self, *args)
    def getMaxTokenLength(self): return _lucenepp.StandardAnalyzer_getMaxTokenLength(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.StandardAnalyzer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.StandardAnalyzer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return StandardAnalyzer.__cast_(obj)

StandardAnalyzer_swigregister = _lucenepp.StandardAnalyzer_swigregister
StandardAnalyzer_swigregister(StandardAnalyzer)
StandardAnalyzer.DEFAULT_MAX_TOKEN_LENGTH = _lucenepp.cvar.StandardAnalyzer_DEFAULT_MAX_TOKEN_LENGTH

def StandardAnalyzer___cast_(*args):
  return _lucenepp.StandardAnalyzer___cast_(*args)
StandardAnalyzer___cast_ = _lucenepp.StandardAnalyzer___cast_

class StandardFilter(TokenFilter):
    __swig_setmethods__ = {}
    for _s in [TokenFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StandardFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [TokenFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StandardFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_StandardFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_StandardFilter
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.StandardFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.StandardFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return StandardFilter.__cast_(obj)

StandardFilter_swigregister = _lucenepp.StandardFilter_swigregister
StandardFilter_swigregister(StandardFilter)

def StandardFilter___cast_(*args):
  return _lucenepp.StandardFilter___cast_(*args)
StandardFilter___cast_ = _lucenepp.StandardFilter___cast_

class StandardTokenizer(Tokenizer):
    __swig_setmethods__ = {}
    for _s in [Tokenizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StandardTokenizer, name, value)
    __swig_getmethods__ = {}
    for _s in [Tokenizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StandardTokenizer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_StandardTokenizer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_StandardTokenizer
    __del__ = lambda self : None;
    __swig_getmethods__["TOKEN_TYPES"] = lambda x: _lucenepp.StandardTokenizer_TOKEN_TYPES
    if _newclass:TOKEN_TYPES = staticmethod(_lucenepp.StandardTokenizer_TOKEN_TYPES)
    def setMaxTokenLength(self, *args): return _lucenepp.StandardTokenizer_setMaxTokenLength(self, *args)
    def getMaxTokenLength(self): return _lucenepp.StandardTokenizer_getMaxTokenLength(self)
    def isReplaceInvalidAcronym(self): return _lucenepp.StandardTokenizer_isReplaceInvalidAcronym(self)
    def setReplaceInvalidAcronym(self, *args): return _lucenepp.StandardTokenizer_setReplaceInvalidAcronym(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.StandardTokenizer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.StandardTokenizer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return StandardTokenizer.__cast_(obj)

StandardTokenizer_swigregister = _lucenepp.StandardTokenizer_swigregister
StandardTokenizer_swigregister(StandardTokenizer)
StandardTokenizer.ALPHANUM = _lucenepp.cvar.StandardTokenizer_ALPHANUM
StandardTokenizer.APOSTROPHE = _lucenepp.cvar.StandardTokenizer_APOSTROPHE
StandardTokenizer.ACRONYM = _lucenepp.cvar.StandardTokenizer_ACRONYM
StandardTokenizer.COMPANY = _lucenepp.cvar.StandardTokenizer_COMPANY
StandardTokenizer.EMAIL = _lucenepp.cvar.StandardTokenizer_EMAIL
StandardTokenizer.HOST = _lucenepp.cvar.StandardTokenizer_HOST
StandardTokenizer.NUM = _lucenepp.cvar.StandardTokenizer_NUM
StandardTokenizer.CJ = _lucenepp.cvar.StandardTokenizer_CJ
StandardTokenizer.ACRONYM_DEP = _lucenepp.cvar.StandardTokenizer_ACRONYM_DEP

def StandardTokenizer_TOKEN_TYPES():
  return _lucenepp.StandardTokenizer_TOKEN_TYPES()
StandardTokenizer_TOKEN_TYPES = _lucenepp.StandardTokenizer_TOKEN_TYPES

def StandardTokenizer___cast_(*args):
  return _lucenepp.StandardTokenizer___cast_(*args)
StandardTokenizer___cast_ = _lucenepp.StandardTokenizer___cast_

class StopAnalyzer(Analyzer):
    __swig_setmethods__ = {}
    for _s in [Analyzer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StopAnalyzer, name, value)
    __swig_getmethods__ = {}
    for _s in [Analyzer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StopAnalyzer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_StopAnalyzer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_StopAnalyzer
    __del__ = lambda self : None;
    __swig_getmethods__["ENGLISH_STOP_WORDS_SET"] = lambda x: _lucenepp.StopAnalyzer_ENGLISH_STOP_WORDS_SET
    if _newclass:ENGLISH_STOP_WORDS_SET = staticmethod(_lucenepp.StopAnalyzer_ENGLISH_STOP_WORDS_SET)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.StopAnalyzer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.StopAnalyzer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return StopAnalyzer.__cast_(obj)

StopAnalyzer_swigregister = _lucenepp.StopAnalyzer_swigregister
StopAnalyzer_swigregister(StopAnalyzer)

def StopAnalyzer_ENGLISH_STOP_WORDS_SET():
  return _lucenepp.StopAnalyzer_ENGLISH_STOP_WORDS_SET()
StopAnalyzer_ENGLISH_STOP_WORDS_SET = _lucenepp.StopAnalyzer_ENGLISH_STOP_WORDS_SET

def StopAnalyzer___cast_(*args):
  return _lucenepp.StopAnalyzer___cast_(*args)
StopAnalyzer___cast_ = _lucenepp.StopAnalyzer___cast_

class StopFilter(TokenFilter):
    __swig_setmethods__ = {}
    for _s in [TokenFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StopFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [TokenFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StopFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_StopFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_StopFilter
    __del__ = lambda self : None;
    __swig_getmethods__["makeStopSet"] = lambda x: _lucenepp.StopFilter_makeStopSet
    if _newclass:makeStopSet = staticmethod(_lucenepp.StopFilter_makeStopSet)
    __swig_getmethods__["getEnablePositionIncrementsVersionDefault"] = lambda x: _lucenepp.StopFilter_getEnablePositionIncrementsVersionDefault
    if _newclass:getEnablePositionIncrementsVersionDefault = staticmethod(_lucenepp.StopFilter_getEnablePositionIncrementsVersionDefault)
    def getEnablePositionIncrements(self): return _lucenepp.StopFilter_getEnablePositionIncrements(self)
    def setEnablePositionIncrements(self, *args): return _lucenepp.StopFilter_setEnablePositionIncrements(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.StopFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.StopFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return StopFilter.__cast_(obj)

StopFilter_swigregister = _lucenepp.StopFilter_swigregister
StopFilter_swigregister(StopFilter)

def StopFilter_makeStopSet(*args):
  return _lucenepp.StopFilter_makeStopSet(*args)
StopFilter_makeStopSet = _lucenepp.StopFilter_makeStopSet

def StopFilter_getEnablePositionIncrementsVersionDefault(*args):
  return _lucenepp.StopFilter_getEnablePositionIncrementsVersionDefault(*args)
StopFilter_getEnablePositionIncrementsVersionDefault = _lucenepp.StopFilter_getEnablePositionIncrementsVersionDefault

def StopFilter___cast_(*args):
  return _lucenepp.StopFilter___cast_(*args)
StopFilter___cast_ = _lucenepp.StopFilter___cast_

class TeeSinkTokenFilter(TokenFilter):
    __swig_setmethods__ = {}
    for _s in [TokenFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TeeSinkTokenFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [TokenFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TeeSinkTokenFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_TeeSinkTokenFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_TeeSinkTokenFilter
    __del__ = lambda self : None;
    def newSinkTokenStream(self, *args): return _lucenepp.TeeSinkTokenFilter_newSinkTokenStream(self, *args)
    def addSinkTokenStream(self, *args): return _lucenepp.TeeSinkTokenFilter_addSinkTokenStream(self, *args)
    def consumeAllTokens(self): return _lucenepp.TeeSinkTokenFilter_consumeAllTokens(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TeeSinkTokenFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TeeSinkTokenFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TeeSinkTokenFilter.__cast_(obj)

TeeSinkTokenFilter_swigregister = _lucenepp.TeeSinkTokenFilter_swigregister
TeeSinkTokenFilter_swigregister(TeeSinkTokenFilter)

def TeeSinkTokenFilter___cast_(*args):
  return _lucenepp.TeeSinkTokenFilter___cast_(*args)
TeeSinkTokenFilter___cast_ = _lucenepp.TeeSinkTokenFilter___cast_

class SinkFilter(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SinkFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SinkFilter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SinkFilter
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.SinkFilter_getClassName(self)
    def accept(self, *args): return _lucenepp.SinkFilter_accept(self, *args)
    def reset(self): return _lucenepp.SinkFilter_reset(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SinkFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SinkFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SinkFilter.__cast_(obj)

SinkFilter_swigregister = _lucenepp.SinkFilter_swigregister
SinkFilter_swigregister(SinkFilter)

def SinkFilter___cast_(*args):
  return _lucenepp.SinkFilter___cast_(*args)
SinkFilter___cast_ = _lucenepp.SinkFilter___cast_

class TermAttribute(Attribute):
    __swig_setmethods__ = {}
    for _s in [Attribute]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermAttribute, name, value)
    __swig_getmethods__ = {}
    for _s in [Attribute]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TermAttribute, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_TermAttribute()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_TermAttribute
    __del__ = lambda self : None;
    def term(self): return _lucenepp.TermAttribute_term(self)
    def setTermBuffer(self, *args): return _lucenepp.TermAttribute_setTermBuffer(self, *args)
    def termBuffer(self): return _lucenepp.TermAttribute_termBuffer(self)
    def termBufferArray(self): return _lucenepp.TermAttribute_termBufferArray(self)
    def resizeTermBuffer(self, *args): return _lucenepp.TermAttribute_resizeTermBuffer(self, *args)
    def termLength(self): return _lucenepp.TermAttribute_termLength(self)
    def setTermLength(self, *args): return _lucenepp.TermAttribute_setTermLength(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermAttribute___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermAttribute___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermAttribute.__cast_(obj)

TermAttribute_swigregister = _lucenepp.TermAttribute_swigregister
TermAttribute_swigregister(TermAttribute)

def TermAttribute___cast_(*args):
  return _lucenepp.TermAttribute___cast_(*args)
TermAttribute___cast_ = _lucenepp.TermAttribute___cast_

class TypeAttribute(Attribute):
    __swig_setmethods__ = {}
    for _s in [Attribute]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TypeAttribute, name, value)
    __swig_getmethods__ = {}
    for _s in [Attribute]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TypeAttribute, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_TypeAttribute(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_TypeAttribute
    __del__ = lambda self : None;
    def type(self): return _lucenepp.TypeAttribute_type(self)
    def setType(self, *args): return _lucenepp.TypeAttribute_setType(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TypeAttribute___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TypeAttribute___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TypeAttribute.__cast_(obj)

TypeAttribute_swigregister = _lucenepp.TypeAttribute_swigregister
TypeAttribute_swigregister(TypeAttribute)

def TypeAttribute___cast_(*args):
  return _lucenepp.TypeAttribute___cast_(*args)
TypeAttribute___cast_ = _lucenepp.TypeAttribute___cast_

class WhitespaceAnalyzer(Analyzer):
    __swig_setmethods__ = {}
    for _s in [Analyzer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WhitespaceAnalyzer, name, value)
    __swig_getmethods__ = {}
    for _s in [Analyzer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WhitespaceAnalyzer, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_WhitespaceAnalyzer
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.WhitespaceAnalyzer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.WhitespaceAnalyzer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return WhitespaceAnalyzer.__cast_(obj)

    def __init__(self): 
        this = _lucenepp.new_WhitespaceAnalyzer()
        try: self.this.append(this)
        except: self.this = this
WhitespaceAnalyzer_swigregister = _lucenepp.WhitespaceAnalyzer_swigregister
WhitespaceAnalyzer_swigregister(WhitespaceAnalyzer)

def WhitespaceAnalyzer___cast_(*args):
  return _lucenepp.WhitespaceAnalyzer___cast_(*args)
WhitespaceAnalyzer___cast_ = _lucenepp.WhitespaceAnalyzer___cast_

class WhitespaceTokenizer(CharTokenizer):
    __swig_setmethods__ = {}
    for _s in [CharTokenizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WhitespaceTokenizer, name, value)
    __swig_getmethods__ = {}
    for _s in [CharTokenizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WhitespaceTokenizer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_WhitespaceTokenizer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_WhitespaceTokenizer
    __del__ = lambda self : None;
    def isTokenChar(self, *args): return _lucenepp.WhitespaceTokenizer_isTokenChar(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.WhitespaceTokenizer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.WhitespaceTokenizer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return WhitespaceTokenizer.__cast_(obj)

WhitespaceTokenizer_swigregister = _lucenepp.WhitespaceTokenizer_swigregister
WhitespaceTokenizer_swigregister(WhitespaceTokenizer)

def WhitespaceTokenizer___cast_(*args):
  return _lucenepp.WhitespaceTokenizer___cast_(*args)
WhitespaceTokenizer___cast_ = _lucenepp.WhitespaceTokenizer___cast_

class Directory(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Directory, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Directory, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Directory
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Directory_getClassName(self)
    def listAll(self): return _lucenepp.Directory_listAll(self)
    def fileExists(self, *args): return _lucenepp.Directory_fileExists(self, *args)
    def fileModified(self, *args): return _lucenepp.Directory_fileModified(self, *args)
    def touchFile(self, *args): return _lucenepp.Directory_touchFile(self, *args)
    def deleteFile(self, *args): return _lucenepp.Directory_deleteFile(self, *args)
    def fileLength(self, *args): return _lucenepp.Directory_fileLength(self, *args)
    def close(self): return _lucenepp.Directory_close(self)
    def sync(self, *args): return _lucenepp.Directory_sync(self, *args)
    def makeLock(self, *args): return _lucenepp.Directory_makeLock(self, *args)
    def clearLock(self, *args): return _lucenepp.Directory_clearLock(self, *args)
    def setLockFactory(self, *args): return _lucenepp.Directory_setLockFactory(self, *args)
    def getLockFactory(self): return _lucenepp.Directory_getLockFactory(self)
    def getLockID(self): return _lucenepp.Directory_getLockID(self)
    __swig_getmethods__["copy"] = lambda x: _lucenepp.Directory_copy
    if _newclass:copy = staticmethod(_lucenepp.Directory_copy)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Directory___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Directory___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Directory.__cast_(obj)

Directory_swigregister = _lucenepp.Directory_swigregister
Directory_swigregister(Directory)

def Directory_copy(*args):
  return _lucenepp.Directory_copy(*args)
Directory_copy = _lucenepp.Directory_copy

def Directory___cast_(*args):
  return _lucenepp.Directory___cast_(*args)
Directory___cast_ = _lucenepp.Directory___cast_

class FSDirectory(Directory):
    __swig_setmethods__ = {}
    for _s in [Directory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FSDirectory, name, value)
    __swig_getmethods__ = {}
    for _s in [Directory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FSDirectory, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FSDirectory
    __del__ = lambda self : None;
    __swig_getmethods__["open"] = lambda x: _lucenepp.FSDirectory_open
    if _newclass:open = staticmethod(_lucenepp.FSDirectory_open)
    def createDir(self): return _lucenepp.FSDirectory_createDir(self)
    def getFile(self): return _lucenepp.FSDirectory_getFile(self)
    def setReadChunkSize(self, *args): return _lucenepp.FSDirectory_setReadChunkSize(self, *args)
    def getReadChunkSize(self): return _lucenepp.FSDirectory_getReadChunkSize(self)
    def listAll(self, *args): return _lucenepp.FSDirectory_listAll(self, *args)
    def fileModified(self, *args): return _lucenepp.FSDirectory_fileModified(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FSDirectory___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FSDirectory___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FSDirectory.__cast_(obj)

FSDirectory_swigregister = _lucenepp.FSDirectory_swigregister
FSDirectory_swigregister(FSDirectory)
FSDirectory.DEFAULT_READ_CHUNK_SIZE = _lucenepp.cvar.FSDirectory_DEFAULT_READ_CHUNK_SIZE

def FSDirectory_open(*args):
  return _lucenepp.FSDirectory_open(*args)
FSDirectory_open = _lucenepp.FSDirectory_open

def FSDirectory___cast_(*args):
  return _lucenepp.FSDirectory___cast_(*args)
FSDirectory___cast_ = _lucenepp.FSDirectory___cast_

class SimpleFSDirectory(FSDirectory):
    __swig_setmethods__ = {}
    for _s in [FSDirectory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleFSDirectory, name, value)
    __swig_getmethods__ = {}
    for _s in [FSDirectory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleFSDirectory, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SimpleFSDirectory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SimpleFSDirectory
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SimpleFSDirectory___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SimpleFSDirectory___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SimpleFSDirectory.__cast_(obj)

SimpleFSDirectory_swigregister = _lucenepp.SimpleFSDirectory_swigregister
SimpleFSDirectory_swigregister(SimpleFSDirectory)

def SimpleFSDirectory___cast_(*args):
  return _lucenepp.SimpleFSDirectory___cast_(*args)
SimpleFSDirectory___cast_ = _lucenepp.SimpleFSDirectory___cast_

class Lock(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Lock, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Lock, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Lock
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Lock_getClassName(self)
    def release(self): return _lucenepp.Lock_release(self)
    def isLocked(self): return _lucenepp.Lock_isLocked(self)
    def obtain(self, *args): return _lucenepp.Lock_obtain(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Lock___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Lock___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Lock.__cast_(obj)

Lock_swigregister = _lucenepp.Lock_swigregister
Lock_swigregister(Lock)
Lock.LOCK_OBTAIN_WAIT_FOREVER = _lucenepp.cvar.Lock_LOCK_OBTAIN_WAIT_FOREVER
Lock.LOCK_POLL_INTERVAL = _lucenepp.cvar.Lock_LOCK_POLL_INTERVAL

def Lock___cast_(*args):
  return _lucenepp.Lock___cast_(*args)
Lock___cast_ = _lucenepp.Lock___cast_

class MMapDirectory(FSDirectory):
    __swig_setmethods__ = {}
    for _s in [FSDirectory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MMapDirectory, name, value)
    __swig_getmethods__ = {}
    for _s in [FSDirectory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MMapDirectory, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_MMapDirectory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_MMapDirectory
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.MMapDirectory___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.MMapDirectory___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return MMapDirectory.__cast_(obj)

MMapDirectory_swigregister = _lucenepp.MMapDirectory_swigregister
MMapDirectory_swigregister(MMapDirectory)

def MMapDirectory___cast_(*args):
  return _lucenepp.MMapDirectory___cast_(*args)
MMapDirectory___cast_ = _lucenepp.MMapDirectory___cast_

class RAMDirectory(Directory):
    __swig_setmethods__ = {}
    for _s in [Directory]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RAMDirectory, name, value)
    __swig_getmethods__ = {}
    for _s in [Directory]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RAMDirectory, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_RAMDirectory(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_RAMDirectory
    __del__ = lambda self : None;
    def sizeInBytes(self): return _lucenepp.RAMDirectory_sizeInBytes(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.RAMDirectory___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.RAMDirectory___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return RAMDirectory.__cast_(obj)

RAMDirectory_swigregister = _lucenepp.RAMDirectory_swigregister
RAMDirectory_swigregister(RAMDirectory)

def RAMDirectory___cast_(*args):
  return _lucenepp.RAMDirectory___cast_(*args)
RAMDirectory___cast_ = _lucenepp.RAMDirectory___cast_

class Term(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Term, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Term, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_Term(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Term
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Term_getClassName(self)
    __swig_setmethods__["_field"] = _lucenepp.Term__field_set
    __swig_getmethods__["_field"] = _lucenepp.Term__field_get
    if _newclass:_field = _swig_property(_lucenepp.Term__field_get, _lucenepp.Term__field_set)
    __swig_setmethods__["_text"] = _lucenepp.Term__text_set
    __swig_getmethods__["_text"] = _lucenepp.Term__text_get
    if _newclass:_text = _swig_property(_lucenepp.Term__text_get, _lucenepp.Term__text_set)
    def field(self): return _lucenepp.Term_field(self)
    def text(self): return _lucenepp.Term_text(self)
    def createTerm(self, *args): return _lucenepp.Term_createTerm(self, *args)
    def set(self, *args): return _lucenepp.Term_set(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Term___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Term___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Term.__cast_(obj)

Term_swigregister = _lucenepp.Term_swigregister
Term_swigregister(Term)

def Term___cast_(*args):
  return _lucenepp.Term___cast_(*args)
Term___cast_ = _lucenepp.Term___cast_

class TermEnum(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermEnum, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TermEnum, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TermEnum
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.TermEnum_getClassName(self)
    def next(self): return _lucenepp.TermEnum_next(self)
    def term(self): return _lucenepp.TermEnum_term(self)
    def docFreq(self): return _lucenepp.TermEnum_docFreq(self)
    def close(self): return _lucenepp.TermEnum_close(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermEnum___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermEnum___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermEnum.__cast_(obj)

TermEnum_swigregister = _lucenepp.TermEnum_swigregister
TermEnum_swigregister(TermEnum)

def TermEnum___cast_(*args):
  return _lucenepp.TermEnum___cast_(*args)
TermEnum___cast_ = _lucenepp.TermEnum___cast_

class TermDocs(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermDocs, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TermDocs, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassName(self): return _lucenepp.TermDocs_getClassName(self)
    def seek(self, *args): return _lucenepp.TermDocs_seek(self, *args)
    def doc(self): return _lucenepp.TermDocs_doc(self)
    def freq(self): return _lucenepp.TermDocs_freq(self)
    def next(self): return _lucenepp.TermDocs_next(self)
    def read(self, *args): return _lucenepp.TermDocs_read(self, *args)
    def skipTo(self, *args): return _lucenepp.TermDocs_skipTo(self, *args)
    def close(self): return _lucenepp.TermDocs_close(self)
    def toLuceneObject__(self, *args): return _lucenepp.TermDocs_toLuceneObject__(self, *args)
    def toLuceneObject(self): return self.toLuceneObject__(self)

    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermDocs___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermDocs___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermDocs.__cast_(obj)

    __swig_destroy__ = _lucenepp.delete_TermDocs
    __del__ = lambda self : None;
TermDocs_swigregister = _lucenepp.TermDocs_swigregister
TermDocs_swigregister(TermDocs)

def TermDocs___cast_(*args):
  return _lucenepp.TermDocs___cast_(*args)
TermDocs___cast_ = _lucenepp.TermDocs___cast_

class TermFreqVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermFreqVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TermFreqVector, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TermFreqVector
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.TermFreqVector_getClassName(self)
    def getField(self): return _lucenepp.TermFreqVector_getField(self)
    def size(self): return _lucenepp.TermFreqVector_size(self)
    def getTerms(self): return _lucenepp.TermFreqVector_getTerms(self)
    def getTermFrequencies(self): return _lucenepp.TermFreqVector_getTermFrequencies(self)
    def indexOf(self, *args): return _lucenepp.TermFreqVector_indexOf(self, *args)
    def indexesOf(self, *args): return _lucenepp.TermFreqVector_indexesOf(self, *args)
    def toLuceneObject__(self, *args): return _lucenepp.TermFreqVector_toLuceneObject__(self, *args)
    def toLuceneObject(self): return self.toLuceneObject__(self)

    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermFreqVector___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermFreqVector___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermFreqVector.__cast_(obj)

TermFreqVector_swigregister = _lucenepp.TermFreqVector_swigregister
TermFreqVector_swigregister(TermFreqVector)

def TermFreqVector___cast_(*args):
  return _lucenepp.TermFreqVector___cast_(*args)
TermFreqVector___cast_ = _lucenepp.TermFreqVector___cast_

class TermPositions(TermDocs):
    __swig_setmethods__ = {}
    for _s in [TermDocs]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermPositions, name, value)
    __swig_getmethods__ = {}
    for _s in [TermDocs]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TermPositions, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TermPositions
    __del__ = lambda self : None;
    def nextPosition(self): return _lucenepp.TermPositions_nextPosition(self)
    def getPayloadLength(self): return _lucenepp.TermPositions_getPayloadLength(self)
    def getPayload(self, *args): return _lucenepp.TermPositions_getPayload(self, *args)
    def isPayloadAvailable(self): return _lucenepp.TermPositions_isPayloadAvailable(self)
    def toLuceneObject__(self, *args): return _lucenepp.TermPositions_toLuceneObject__(self, *args)
    def toLuceneObject(self): return self.toLuceneObject__(self)

    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermPositions___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermPositions___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermPositions.__cast_(obj)

TermPositions_swigregister = _lucenepp.TermPositions_swigregister
TermPositions_swigregister(TermPositions)

def TermPositions___cast_(*args):
  return _lucenepp.TermPositions___cast_(*args)
TermPositions___cast_ = _lucenepp.TermPositions___cast_

class TermPositionVector(TermFreqVector):
    __swig_setmethods__ = {}
    for _s in [TermFreqVector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermPositionVector, name, value)
    __swig_getmethods__ = {}
    for _s in [TermFreqVector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TermPositionVector, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TermPositionVector
    __del__ = lambda self : None;
    def getTermPositions(self, *args): return _lucenepp.TermPositionVector_getTermPositions(self, *args)
    def getOffsets(self, *args): return _lucenepp.TermPositionVector_getOffsets(self, *args)
    def toLuceneObject__(self, *args): return _lucenepp.TermPositionVector_toLuceneObject__(self, *args)
    def toLuceneObject(self): return self.toLuceneObject__(self)

    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermPositionVector___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermPositionVector___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermPositionVector.__cast_(obj)

TermPositionVector_swigregister = _lucenepp.TermPositionVector_swigregister
TermPositionVector_swigregister(TermPositionVector)

def TermPositionVector___cast_(*args):
  return _lucenepp.TermPositionVector___cast_(*args)
TermPositionVector___cast_ = _lucenepp.TermPositionVector___cast_

class IndexReader(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndexReader, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IndexReader, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_IndexReader
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.IndexReader_getClassName(self)
    FIELD_OPTION_ALL = _lucenepp.IndexReader_FIELD_OPTION_ALL
    FIELD_OPTION_INDEXED = _lucenepp.IndexReader_FIELD_OPTION_INDEXED
    FIELD_OPTION_STORES_PAYLOADS = _lucenepp.IndexReader_FIELD_OPTION_STORES_PAYLOADS
    FIELD_OPTION_OMIT_TERM_FREQ_AND_POSITIONS = _lucenepp.IndexReader_FIELD_OPTION_OMIT_TERM_FREQ_AND_POSITIONS
    FIELD_OPTION_UNINDEXED = _lucenepp.IndexReader_FIELD_OPTION_UNINDEXED
    FIELD_OPTION_INDEXED_WITH_TERMVECTOR = _lucenepp.IndexReader_FIELD_OPTION_INDEXED_WITH_TERMVECTOR
    FIELD_OPTION_INDEXED_NO_TERMVECTOR = _lucenepp.IndexReader_FIELD_OPTION_INDEXED_NO_TERMVECTOR
    FIELD_OPTION_TERMVECTOR = _lucenepp.IndexReader_FIELD_OPTION_TERMVECTOR
    FIELD_OPTION_TERMVECTOR_WITH_POSITION = _lucenepp.IndexReader_FIELD_OPTION_TERMVECTOR_WITH_POSITION
    FIELD_OPTION_TERMVECTOR_WITH_OFFSET = _lucenepp.IndexReader_FIELD_OPTION_TERMVECTOR_WITH_OFFSET
    FIELD_OPTION_TERMVECTOR_WITH_POSITION_OFFSET = _lucenepp.IndexReader_FIELD_OPTION_TERMVECTOR_WITH_POSITION_OFFSET
    def getRefCount(self): return _lucenepp.IndexReader_getRefCount(self)
    def incRef(self): return _lucenepp.IndexReader_incRef(self)
    def decRef(self): return _lucenepp.IndexReader_decRef(self)
    __swig_getmethods__["open"] = lambda x: _lucenepp.IndexReader_open
    if _newclass:open = staticmethod(_lucenepp.IndexReader_open)
    def reopen(self, *args): return _lucenepp.IndexReader_reopen(self, *args)
    def directory(self): return _lucenepp.IndexReader_directory(self)
    __swig_getmethods__["lastModified"] = lambda x: _lucenepp.IndexReader_lastModified
    if _newclass:lastModified = staticmethod(_lucenepp.IndexReader_lastModified)
    __swig_getmethods__["getCurrentVersion"] = lambda x: _lucenepp.IndexReader_getCurrentVersion
    if _newclass:getCurrentVersion = staticmethod(_lucenepp.IndexReader_getCurrentVersion)
    def getVersion(self): return _lucenepp.IndexReader_getVersion(self)
    def getCommitUserData(self, *args): return _lucenepp.IndexReader_getCommitUserData(self, *args)
    def isCurrent(self): return _lucenepp.IndexReader_isCurrent(self)
    def isOptimized(self): return _lucenepp.IndexReader_isOptimized(self)
    def getTermFreqVectors(self, *args): return _lucenepp.IndexReader_getTermFreqVectors(self, *args)
    def getTermFreqVector(self, *args): return _lucenepp.IndexReader_getTermFreqVector(self, *args)
    __swig_getmethods__["indexExists"] = lambda x: _lucenepp.IndexReader_indexExists
    if _newclass:indexExists = staticmethod(_lucenepp.IndexReader_indexExists)
    def numDocs(self): return _lucenepp.IndexReader_numDocs(self)
    def maxDoc(self): return _lucenepp.IndexReader_maxDoc(self)
    def numDeletedDocs(self): return _lucenepp.IndexReader_numDeletedDocs(self)
    def document(self, *args): return _lucenepp.IndexReader_document(self, *args)
    def isDeleted(self, *args): return _lucenepp.IndexReader_isDeleted(self, *args)
    def hasDeletions(self): return _lucenepp.IndexReader_hasDeletions(self)
    def hasChanges(self): return _lucenepp.IndexReader_hasChanges(self)
    def hasNorms(self, *args): return _lucenepp.IndexReader_hasNorms(self, *args)
    def norms(self, *args): return _lucenepp.IndexReader_norms(self, *args)
    def setNorm(self, *args): return _lucenepp.IndexReader_setNorm(self, *args)
    def terms(self, *args): return _lucenepp.IndexReader_terms(self, *args)
    def docFreq(self, *args): return _lucenepp.IndexReader_docFreq(self, *args)
    def termDocs(self, *args): return _lucenepp.IndexReader_termDocs(self, *args)
    def termPositions(self, *args): return _lucenepp.IndexReader_termPositions(self, *args)
    def deleteDocument(self, *args): return _lucenepp.IndexReader_deleteDocument(self, *args)
    def deleteDocuments(self, *args): return _lucenepp.IndexReader_deleteDocuments(self, *args)
    def undeleteAll(self): return _lucenepp.IndexReader_undeleteAll(self)
    def flush(self, *args): return _lucenepp.IndexReader_flush(self, *args)
    def commit(self, *args): return _lucenepp.IndexReader_commit(self, *args)
    def close(self): return _lucenepp.IndexReader_close(self)
    def getFieldNames(self, *args): return _lucenepp.IndexReader_getFieldNames(self, *args)
    def getIndexCommit(self): return _lucenepp.IndexReader_getIndexCommit(self)
    __swig_getmethods__["main"] = lambda x: _lucenepp.IndexReader_main
    if _newclass:main = staticmethod(_lucenepp.IndexReader_main)
    __swig_getmethods__["listCommits"] = lambda x: _lucenepp.IndexReader_listCommits
    if _newclass:listCommits = staticmethod(_lucenepp.IndexReader_listCommits)
    def getSequentialSubReaders(self): return _lucenepp.IndexReader_getSequentialSubReaders(self)
    def getFieldCacheKey(self): return _lucenepp.IndexReader_getFieldCacheKey(self)
    def getDeletesCacheKey(self): return _lucenepp.IndexReader_getDeletesCacheKey(self)
    def getUniqueTermCount(self): return _lucenepp.IndexReader_getUniqueTermCount(self)
    def getTermInfosIndexDivisor(self): return _lucenepp.IndexReader_getTermInfosIndexDivisor(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.IndexReader___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.IndexReader___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return IndexReader.__cast_(obj)

IndexReader_swigregister = _lucenepp.IndexReader_swigregister
IndexReader_swigregister(IndexReader)
IndexReader.DEFAULT_TERMS_INDEX_DIVISOR = _lucenepp.cvar.IndexReader_DEFAULT_TERMS_INDEX_DIVISOR

def IndexReader_open(*args):
  return _lucenepp.IndexReader_open(*args)
IndexReader_open = _lucenepp.IndexReader_open

def IndexReader_lastModified(*args):
  return _lucenepp.IndexReader_lastModified(*args)
IndexReader_lastModified = _lucenepp.IndexReader_lastModified

def IndexReader_getCurrentVersion(*args):
  return _lucenepp.IndexReader_getCurrentVersion(*args)
IndexReader_getCurrentVersion = _lucenepp.IndexReader_getCurrentVersion

def IndexReader_indexExists(*args):
  return _lucenepp.IndexReader_indexExists(*args)
IndexReader_indexExists = _lucenepp.IndexReader_indexExists

def IndexReader_main(*args):
  return _lucenepp.IndexReader_main(*args)
IndexReader_main = _lucenepp.IndexReader_main

def IndexReader_listCommits(*args):
  return _lucenepp.IndexReader_listCommits(*args)
IndexReader_listCommits = _lucenepp.IndexReader_listCommits

def IndexReader___cast_(*args):
  return _lucenepp.IndexReader___cast_(*args)
IndexReader___cast_ = _lucenepp.IndexReader___cast_

class ParallelReader(IndexReader):
    __swig_setmethods__ = {}
    for _s in [IndexReader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParallelReader, name, value)
    __swig_getmethods__ = {}
    for _s in [IndexReader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParallelReader, name)
    __repr__ = _swig_repr
    def __init__(self, closeSubReaders = True): 
        this = _lucenepp.new_ParallelReader(closeSubReaders)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_ParallelReader
    __del__ = lambda self : None;
    def add(self, *args): return _lucenepp.ParallelReader_add(self, *args)
    def getTermFreqVector(self, *args): return _lucenepp.ParallelReader_getTermFreqVector(self, *args)
    def norms(self, *args): return _lucenepp.ParallelReader_norms(self, *args)
    def terms(self, *args): return _lucenepp.ParallelReader_terms(self, *args)
    def termDocs(self, *args): return _lucenepp.ParallelReader_termDocs(self, *args)
    def termPositions(self, *args): return _lucenepp.ParallelReader_termPositions(self, *args)
    def getSubReaders(self): return _lucenepp.ParallelReader_getSubReaders(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.ParallelReader___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.ParallelReader___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return ParallelReader.__cast_(obj)

ParallelReader_swigregister = _lucenepp.ParallelReader_swigregister
ParallelReader_swigregister(ParallelReader)

def ParallelReader___cast_(*args):
  return _lucenepp.ParallelReader___cast_(*args)
ParallelReader___cast_ = _lucenepp.ParallelReader___cast_

class SegmentInfoCollection(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SegmentInfoCollection, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SegmentInfoCollection, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_SegmentInfoCollection()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SegmentInfoCollection
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.SegmentInfoCollection_getClassName(self)
    def size(self): return _lucenepp.SegmentInfoCollection_size(self)
    def empty(self): return _lucenepp.SegmentInfoCollection_empty(self)
    def clear(self): return _lucenepp.SegmentInfoCollection_clear(self)
    def add(self, *args): return _lucenepp.SegmentInfoCollection_add(self, *args)
    def addAll(self, *args): return _lucenepp.SegmentInfoCollection_addAll(self, *args)
    def find(self, *args): return _lucenepp.SegmentInfoCollection_find(self, *args)
    def contains(self, *args): return _lucenepp.SegmentInfoCollection_contains(self, *args)
    def remove(self, *args): return _lucenepp.SegmentInfoCollection_remove(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SegmentInfoCollection___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SegmentInfoCollection___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SegmentInfoCollection.__cast_(obj)

SegmentInfoCollection_swigregister = _lucenepp.SegmentInfoCollection_swigregister
SegmentInfoCollection_swigregister(SegmentInfoCollection)

def SegmentInfoCollection___cast_(*args):
  return _lucenepp.SegmentInfoCollection___cast_(*args)
SegmentInfoCollection___cast_ = _lucenepp.SegmentInfoCollection___cast_

class TermVectorOffsetInfo(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermVectorOffsetInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TermVectorOffsetInfo, name)
    __repr__ = _swig_repr
    def __init__(self, startOffset = 0, endOffset = 0): 
        this = _lucenepp.new_TermVectorOffsetInfo(startOffset, endOffset)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_TermVectorOffsetInfo
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.TermVectorOffsetInfo_getClassName(self)
    __swig_getmethods__["EMPTY_OFFSET_INFO"] = lambda x: _lucenepp.TermVectorOffsetInfo_EMPTY_OFFSET_INFO
    if _newclass:EMPTY_OFFSET_INFO = staticmethod(_lucenepp.TermVectorOffsetInfo_EMPTY_OFFSET_INFO)
    def getEndOffset(self): return _lucenepp.TermVectorOffsetInfo_getEndOffset(self)
    def setEndOffset(self, *args): return _lucenepp.TermVectorOffsetInfo_setEndOffset(self, *args)
    def getStartOffset(self): return _lucenepp.TermVectorOffsetInfo_getStartOffset(self)
    def setStartOffset(self, *args): return _lucenepp.TermVectorOffsetInfo_setStartOffset(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermVectorOffsetInfo___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermVectorOffsetInfo___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermVectorOffsetInfo.__cast_(obj)

TermVectorOffsetInfo_swigregister = _lucenepp.TermVectorOffsetInfo_swigregister
TermVectorOffsetInfo_swigregister(TermVectorOffsetInfo)

def TermVectorOffsetInfo_EMPTY_OFFSET_INFO():
  return _lucenepp.TermVectorOffsetInfo_EMPTY_OFFSET_INFO()
TermVectorOffsetInfo_EMPTY_OFFSET_INFO = _lucenepp.TermVectorOffsetInfo_EMPTY_OFFSET_INFO

def TermVectorOffsetInfo___cast_(*args):
  return _lucenepp.TermVectorOffsetInfo___cast_(*args)
TermVectorOffsetInfo___cast_ = _lucenepp.TermVectorOffsetInfo___cast_

class IndexFileNameFilter(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndexFileNameFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IndexFileNameFilter, name)
    __repr__ = _swig_repr
    __swig_getmethods__["accept"] = lambda x: _lucenepp.IndexFileNameFilter_accept
    if _newclass:accept = staticmethod(_lucenepp.IndexFileNameFilter_accept)
    __swig_getmethods__["isCFSFile"] = lambda x: _lucenepp.IndexFileNameFilter_isCFSFile
    if _newclass:isCFSFile = staticmethod(_lucenepp.IndexFileNameFilter_isCFSFile)
    __swig_getmethods__["getFilter"] = lambda x: _lucenepp.IndexFileNameFilter_getFilter
    if _newclass:getFilter = staticmethod(_lucenepp.IndexFileNameFilter_getFilter)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.IndexFileNameFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.IndexFileNameFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return IndexFileNameFilter.__cast_(obj)

    def __init__(self): 
        this = _lucenepp.new_IndexFileNameFilter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_IndexFileNameFilter
    __del__ = lambda self : None;
IndexFileNameFilter_swigregister = _lucenepp.IndexFileNameFilter_swigregister
IndexFileNameFilter_swigregister(IndexFileNameFilter)

def IndexFileNameFilter_accept(*args):
  return _lucenepp.IndexFileNameFilter_accept(*args)
IndexFileNameFilter_accept = _lucenepp.IndexFileNameFilter_accept

def IndexFileNameFilter_isCFSFile(*args):
  return _lucenepp.IndexFileNameFilter_isCFSFile(*args)
IndexFileNameFilter_isCFSFile = _lucenepp.IndexFileNameFilter_isCFSFile

def IndexFileNameFilter_getFilter():
  return _lucenepp.IndexFileNameFilter_getFilter()
IndexFileNameFilter_getFilter = _lucenepp.IndexFileNameFilter_getFilter

def IndexFileNameFilter___cast_(*args):
  return _lucenepp.IndexFileNameFilter___cast_(*args)
IndexFileNameFilter___cast_ = _lucenepp.IndexFileNameFilter___cast_

class IndexWriter(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndexWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IndexWriter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_IndexWriter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_IndexWriter
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.IndexWriter_getClassName(self)
    __swig_setmethods__["WRITE_LOCK_TIMEOUT"] = _lucenepp.IndexWriter_WRITE_LOCK_TIMEOUT_set
    __swig_getmethods__["WRITE_LOCK_TIMEOUT"] = _lucenepp.IndexWriter_WRITE_LOCK_TIMEOUT_get
    if _newclass:WRITE_LOCK_TIMEOUT = _swig_property(_lucenepp.IndexWriter_WRITE_LOCK_TIMEOUT_get, _lucenepp.IndexWriter_WRITE_LOCK_TIMEOUT_set)
    __swig_getmethods__["MAX_TERM_LENGTH"] = lambda x: _lucenepp.IndexWriter_MAX_TERM_LENGTH
    if _newclass:MAX_TERM_LENGTH = staticmethod(_lucenepp.IndexWriter_MAX_TERM_LENGTH)
    def getReader(self, *args): return _lucenepp.IndexWriter_getReader(self, *args)
    def numDeletedDocs(self, *args): return _lucenepp.IndexWriter_numDeletedDocs(self, *args)
    def acquireWrite(self): return _lucenepp.IndexWriter_acquireWrite(self)
    def releaseWrite(self): return _lucenepp.IndexWriter_releaseWrite(self)
    def acquireRead(self): return _lucenepp.IndexWriter_acquireRead(self)
    def upgradeReadToWrite(self): return _lucenepp.IndexWriter_upgradeReadToWrite(self)
    def releaseRead(self): return _lucenepp.IndexWriter_releaseRead(self)
    def isOpen(self, *args): return _lucenepp.IndexWriter_isOpen(self, *args)
    def message(self, *args): return _lucenepp.IndexWriter_message(self, *args)
    def getUseCompoundFile(self): return _lucenepp.IndexWriter_getUseCompoundFile(self)
    def setUseCompoundFile(self, *args): return _lucenepp.IndexWriter_setUseCompoundFile(self, *args)
    def setSimilarity(self, *args): return _lucenepp.IndexWriter_setSimilarity(self, *args)
    def getSimilarity(self): return _lucenepp.IndexWriter_getSimilarity(self)
    def setTermIndexInterval(self, *args): return _lucenepp.IndexWriter_setTermIndexInterval(self, *args)
    def getTermIndexInterval(self): return _lucenepp.IndexWriter_getTermIndexInterval(self)
    def setMergePolicy(self, *args): return _lucenepp.IndexWriter_setMergePolicy(self, *args)
    def getMergePolicy(self): return _lucenepp.IndexWriter_getMergePolicy(self)
    def setMergeScheduler(self, *args): return _lucenepp.IndexWriter_setMergeScheduler(self, *args)
    def getMergeScheduler(self): return _lucenepp.IndexWriter_getMergeScheduler(self)
    def setMaxMergeDocs(self, *args): return _lucenepp.IndexWriter_setMaxMergeDocs(self, *args)
    def getMaxMergeDocs(self): return _lucenepp.IndexWriter_getMaxMergeDocs(self)
    def setMaxFieldLength(self, *args): return _lucenepp.IndexWriter_setMaxFieldLength(self, *args)
    def getMaxFieldLength(self): return _lucenepp.IndexWriter_getMaxFieldLength(self)
    def setReaderTermsIndexDivisor(self, *args): return _lucenepp.IndexWriter_setReaderTermsIndexDivisor(self, *args)
    def getReaderTermsIndexDivisor(self): return _lucenepp.IndexWriter_getReaderTermsIndexDivisor(self)
    def setMaxBufferedDocs(self, *args): return _lucenepp.IndexWriter_setMaxBufferedDocs(self, *args)
    def getMaxBufferedDocs(self): return _lucenepp.IndexWriter_getMaxBufferedDocs(self)
    def setRAMBufferSizeMB(self, *args): return _lucenepp.IndexWriter_setRAMBufferSizeMB(self, *args)
    def getRAMBufferSizeMB(self): return _lucenepp.IndexWriter_getRAMBufferSizeMB(self)
    def setMaxBufferedDeleteTerms(self, *args): return _lucenepp.IndexWriter_setMaxBufferedDeleteTerms(self, *args)
    def getMaxBufferedDeleteTerms(self): return _lucenepp.IndexWriter_getMaxBufferedDeleteTerms(self)
    def setMergeFactor(self, *args): return _lucenepp.IndexWriter_setMergeFactor(self, *args)
    def getMergeFactor(self): return _lucenepp.IndexWriter_getMergeFactor(self)
    __swig_getmethods__["setDefaultInfoStream"] = lambda x: _lucenepp.IndexWriter_setDefaultInfoStream
    if _newclass:setDefaultInfoStream = staticmethod(_lucenepp.IndexWriter_setDefaultInfoStream)
    __swig_getmethods__["getDefaultInfoStream"] = lambda x: _lucenepp.IndexWriter_getDefaultInfoStream
    if _newclass:getDefaultInfoStream = staticmethod(_lucenepp.IndexWriter_getDefaultInfoStream)
    def setInfoStream(self, *args): return _lucenepp.IndexWriter_setInfoStream(self, *args)
    def getInfoStream(self): return _lucenepp.IndexWriter_getInfoStream(self)
    def verbose(self): return _lucenepp.IndexWriter_verbose(self)
    def setWriteLockTimeout(self, *args): return _lucenepp.IndexWriter_setWriteLockTimeout(self, *args)
    def getWriteLockTimeout(self): return _lucenepp.IndexWriter_getWriteLockTimeout(self)
    __swig_getmethods__["setDefaultWriteLockTimeout"] = lambda x: _lucenepp.IndexWriter_setDefaultWriteLockTimeout
    if _newclass:setDefaultWriteLockTimeout = staticmethod(_lucenepp.IndexWriter_setDefaultWriteLockTimeout)
    __swig_getmethods__["getDefaultWriteLockTimeout"] = lambda x: _lucenepp.IndexWriter_getDefaultWriteLockTimeout
    if _newclass:getDefaultWriteLockTimeout = staticmethod(_lucenepp.IndexWriter_getDefaultWriteLockTimeout)
    def close(self, *args): return _lucenepp.IndexWriter_close(self, *args)
    def getDirectory(self): return _lucenepp.IndexWriter_getDirectory(self)
    def getAnalyzer(self): return _lucenepp.IndexWriter_getAnalyzer(self)
    def maxDoc(self): return _lucenepp.IndexWriter_maxDoc(self)
    def numDocs(self): return _lucenepp.IndexWriter_numDocs(self)
    def hasDeletions(self): return _lucenepp.IndexWriter_hasDeletions(self)
    def addDocument(self, *args): return _lucenepp.IndexWriter_addDocument(self, *args)
    def deleteDocuments(self, *args): return _lucenepp.IndexWriter_deleteDocuments(self, *args)
    def updateDocument(self, *args): return _lucenepp.IndexWriter_updateDocument(self, *args)
    def getSegmentCount(self): return _lucenepp.IndexWriter_getSegmentCount(self)
    def getNumBufferedDocuments(self): return _lucenepp.IndexWriter_getNumBufferedDocuments(self)
    def getDocCount(self, *args): return _lucenepp.IndexWriter_getDocCount(self, *args)
    def getFlushCount(self): return _lucenepp.IndexWriter_getFlushCount(self)
    def getFlushDeletesCount(self): return _lucenepp.IndexWriter_getFlushDeletesCount(self)
    def newSegmentName(self): return _lucenepp.IndexWriter_newSegmentName(self)
    def optimize(self, *args): return _lucenepp.IndexWriter_optimize(self, *args)
    def expungeDeletes(self, *args): return _lucenepp.IndexWriter_expungeDeletes(self, *args)
    def maybeMerge(self): return _lucenepp.IndexWriter_maybeMerge(self)
    def getNextMerge(self): return _lucenepp.IndexWriter_getNextMerge(self)
    def rollback(self): return _lucenepp.IndexWriter_rollback(self)
    def deleteAll(self): return _lucenepp.IndexWriter_deleteAll(self)
    def waitForMerges(self): return _lucenepp.IndexWriter_waitForMerges(self)
    def addIndexesNoOptimize(self, *args): return _lucenepp.IndexWriter_addIndexesNoOptimize(self, *args)
    def addIndexes(self, *args): return _lucenepp.IndexWriter_addIndexes(self, *args)
    def prepareCommit(self, *args): return _lucenepp.IndexWriter_prepareCommit(self, *args)
    def commit(self, *args): return _lucenepp.IndexWriter_commit(self, *args)
    def ramSizeInBytes(self): return _lucenepp.IndexWriter_ramSizeInBytes(self)
    def numRamDocs(self): return _lucenepp.IndexWriter_numRamDocs(self)
    def merge(self, *args): return _lucenepp.IndexWriter_merge(self, *args)
    def mergeSuccess(self, *args): return _lucenepp.IndexWriter_mergeSuccess(self, *args)
    def registerMerge(self, *args): return _lucenepp.IndexWriter_registerMerge(self, *args)
    def mergeInit(self, *args): return _lucenepp.IndexWriter_mergeInit(self, *args)
    def mergeFinish(self, *args): return _lucenepp.IndexWriter_mergeFinish(self, *args)
    def addMergeException(self, *args): return _lucenepp.IndexWriter_addMergeException(self, *args)
    def getBufferedDeleteTermsSize(self): return _lucenepp.IndexWriter_getBufferedDeleteTermsSize(self)
    def getNumBufferedDeleteTerms(self): return _lucenepp.IndexWriter_getNumBufferedDeleteTerms(self)
    def newestSegment(self): return _lucenepp.IndexWriter_newestSegment(self)
    def segString(self): return _lucenepp.IndexWriter_segString(self)
    __swig_getmethods__["isLocked"] = lambda x: _lucenepp.IndexWriter_isLocked
    if _newclass:isLocked = staticmethod(_lucenepp.IndexWriter_isLocked)
    __swig_getmethods__["unlock"] = lambda x: _lucenepp.IndexWriter_unlock
    if _newclass:unlock = staticmethod(_lucenepp.IndexWriter_unlock)
    def setMergedSegmentWarmer(self, *args): return _lucenepp.IndexWriter_setMergedSegmentWarmer(self, *args)
    def getMergedSegmentWarmer(self): return _lucenepp.IndexWriter_getMergedSegmentWarmer(self)
    def nrtIsCurrent(self, *args): return _lucenepp.IndexWriter_nrtIsCurrent(self, *args)
    def isClosed(self): return _lucenepp.IndexWriter_isClosed(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.IndexWriter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.IndexWriter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return IndexWriter.__cast_(obj)

IndexWriter_swigregister = _lucenepp.IndexWriter_swigregister
IndexWriter_swigregister(IndexWriter)
IndexWriter.WRITE_LOCK_NAME = _lucenepp.cvar.IndexWriter_WRITE_LOCK_NAME
IndexWriter.DISABLE_AUTO_FLUSH = _lucenepp.cvar.IndexWriter_DISABLE_AUTO_FLUSH
IndexWriter.DEFAULT_MAX_BUFFERED_DOCS = _lucenepp.cvar.IndexWriter_DEFAULT_MAX_BUFFERED_DOCS
IndexWriter.DEFAULT_RAM_BUFFER_SIZE_MB = _lucenepp.cvar.IndexWriter_DEFAULT_RAM_BUFFER_SIZE_MB
IndexWriter.DEFAULT_MAX_BUFFERED_DELETE_TERMS = _lucenepp.cvar.IndexWriter_DEFAULT_MAX_BUFFERED_DELETE_TERMS
IndexWriter.DEFAULT_MAX_FIELD_LENGTH = _lucenepp.cvar.IndexWriter_DEFAULT_MAX_FIELD_LENGTH
IndexWriter.DEFAULT_TERM_INDEX_INTERVAL = _lucenepp.cvar.IndexWriter_DEFAULT_TERM_INDEX_INTERVAL

def IndexWriter_MAX_TERM_LENGTH():
  return _lucenepp.IndexWriter_MAX_TERM_LENGTH()
IndexWriter_MAX_TERM_LENGTH = _lucenepp.IndexWriter_MAX_TERM_LENGTH
IndexWriter.MaxFieldLengthUNLIMITED = _lucenepp.cvar.IndexWriter_MaxFieldLengthUNLIMITED
IndexWriter.MaxFieldLengthLIMITED = _lucenepp.cvar.IndexWriter_MaxFieldLengthLIMITED

def IndexWriter_setDefaultInfoStream(*args):
  return _lucenepp.IndexWriter_setDefaultInfoStream(*args)
IndexWriter_setDefaultInfoStream = _lucenepp.IndexWriter_setDefaultInfoStream

def IndexWriter_getDefaultInfoStream():
  return _lucenepp.IndexWriter_getDefaultInfoStream()
IndexWriter_getDefaultInfoStream = _lucenepp.IndexWriter_getDefaultInfoStream

def IndexWriter_setDefaultWriteLockTimeout(*args):
  return _lucenepp.IndexWriter_setDefaultWriteLockTimeout(*args)
IndexWriter_setDefaultWriteLockTimeout = _lucenepp.IndexWriter_setDefaultWriteLockTimeout

def IndexWriter_getDefaultWriteLockTimeout():
  return _lucenepp.IndexWriter_getDefaultWriteLockTimeout()
IndexWriter_getDefaultWriteLockTimeout = _lucenepp.IndexWriter_getDefaultWriteLockTimeout

def IndexWriter_isLocked(*args):
  return _lucenepp.IndexWriter_isLocked(*args)
IndexWriter_isLocked = _lucenepp.IndexWriter_isLocked

def IndexWriter_unlock(*args):
  return _lucenepp.IndexWriter_unlock(*args)
IndexWriter_unlock = _lucenepp.IndexWriter_unlock

def IndexWriter___cast_(*args):
  return _lucenepp.IndexWriter___cast_(*args)
IndexWriter___cast_ = _lucenepp.IndexWriter___cast_

class MultiReader(IndexReader):
    __swig_setmethods__ = {}
    for _s in [IndexReader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiReader, name, value)
    __swig_getmethods__ = {}
    for _s in [IndexReader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiReader, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_MultiReader(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_MultiReader
    __del__ = lambda self : None;
    def getTermFreqVector(self, *args): return _lucenepp.MultiReader_getTermFreqVector(self, *args)
    def norms(self, *args): return _lucenepp.MultiReader_norms(self, *args)
    def terms(self, *args): return _lucenepp.MultiReader_terms(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.MultiReader___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.MultiReader___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return MultiReader.__cast_(obj)

MultiReader_swigregister = _lucenepp.MultiReader_swigregister
MultiReader_swigregister(MultiReader)

def MultiReader___cast_(*args):
  return _lucenepp.MultiReader___cast_(*args)
MultiReader___cast_ = _lucenepp.MultiReader___cast_

class Payload(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Payload, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Payload, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_Payload(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Payload
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Payload_getClassName(self)
    def setData(self, *args): return _lucenepp.Payload_setData(self, *args)
    def getData(self): return _lucenepp.Payload_getData(self)
    def getOffset(self): return _lucenepp.Payload_getOffset(self)
    def length(self): return _lucenepp.Payload_length(self)
    def byteAt(self, *args): return _lucenepp.Payload_byteAt(self, *args)
    def toByteArray(self): return _lucenepp.Payload_toByteArray(self)
    def copyTo(self, *args): return _lucenepp.Payload_copyTo(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Payload___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Payload___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Payload.__cast_(obj)

Payload_swigregister = _lucenepp.Payload_swigregister
Payload_swigregister(Payload)

def Payload___cast_(*args):
  return _lucenepp.Payload___cast_(*args)
Payload___cast_ = _lucenepp.Payload___cast_

class CheckIndex(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CheckIndex, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CheckIndex, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_CheckIndex(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_CheckIndex
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.CheckIndex_getClassName(self)
    def setInfoStream(self, *args): return _lucenepp.CheckIndex_setInfoStream(self, *args)
    def checkIndex(self, *args): return _lucenepp.CheckIndex_checkIndex(self, *args)
    def fixIndex(self, *args): return _lucenepp.CheckIndex_fixIndex(self, *args)
    __swig_getmethods__["testAsserts"] = lambda x: _lucenepp.CheckIndex_testAsserts
    if _newclass:testAsserts = staticmethod(_lucenepp.CheckIndex_testAsserts)
    __swig_getmethods__["assertsOn"] = lambda x: _lucenepp.CheckIndex_assertsOn
    if _newclass:assertsOn = staticmethod(_lucenepp.CheckIndex_assertsOn)
    __swig_getmethods__["main"] = lambda x: _lucenepp.CheckIndex_main
    if _newclass:main = staticmethod(_lucenepp.CheckIndex_main)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.CheckIndex___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.CheckIndex___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return CheckIndex.__cast_(obj)

CheckIndex_swigregister = _lucenepp.CheckIndex_swigregister
CheckIndex_swigregister(CheckIndex)

def CheckIndex_testAsserts():
  return _lucenepp.CheckIndex_testAsserts()
CheckIndex_testAsserts = _lucenepp.CheckIndex_testAsserts

def CheckIndex_assertsOn():
  return _lucenepp.CheckIndex_assertsOn()
CheckIndex_assertsOn = _lucenepp.CheckIndex_assertsOn

def CheckIndex_main(*args):
  return _lucenepp.CheckIndex_main(*args)
CheckIndex_main = _lucenepp.CheckIndex_main

def CheckIndex___cast_(*args):
  return _lucenepp.CheckIndex___cast_(*args)
CheckIndex___cast_ = _lucenepp.CheckIndex___cast_

class IndexStatus(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndexStatus, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IndexStatus, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_IndexStatus()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_IndexStatus
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.IndexStatus_getClassName(self)
    __swig_setmethods__["clean"] = _lucenepp.IndexStatus_clean_set
    __swig_getmethods__["clean"] = _lucenepp.IndexStatus_clean_get
    if _newclass:clean = _swig_property(_lucenepp.IndexStatus_clean_get, _lucenepp.IndexStatus_clean_set)
    __swig_setmethods__["missingSegments"] = _lucenepp.IndexStatus_missingSegments_set
    __swig_getmethods__["missingSegments"] = _lucenepp.IndexStatus_missingSegments_get
    if _newclass:missingSegments = _swig_property(_lucenepp.IndexStatus_missingSegments_get, _lucenepp.IndexStatus_missingSegments_set)
    __swig_setmethods__["cantOpenSegments"] = _lucenepp.IndexStatus_cantOpenSegments_set
    __swig_getmethods__["cantOpenSegments"] = _lucenepp.IndexStatus_cantOpenSegments_get
    if _newclass:cantOpenSegments = _swig_property(_lucenepp.IndexStatus_cantOpenSegments_get, _lucenepp.IndexStatus_cantOpenSegments_set)
    __swig_setmethods__["missingSegmentVersion"] = _lucenepp.IndexStatus_missingSegmentVersion_set
    __swig_getmethods__["missingSegmentVersion"] = _lucenepp.IndexStatus_missingSegmentVersion_get
    if _newclass:missingSegmentVersion = _swig_property(_lucenepp.IndexStatus_missingSegmentVersion_get, _lucenepp.IndexStatus_missingSegmentVersion_set)
    __swig_setmethods__["segmentsFileName"] = _lucenepp.IndexStatus_segmentsFileName_set
    __swig_getmethods__["segmentsFileName"] = _lucenepp.IndexStatus_segmentsFileName_get
    if _newclass:segmentsFileName = _swig_property(_lucenepp.IndexStatus_segmentsFileName_get, _lucenepp.IndexStatus_segmentsFileName_set)
    __swig_setmethods__["numSegments"] = _lucenepp.IndexStatus_numSegments_set
    __swig_getmethods__["numSegments"] = _lucenepp.IndexStatus_numSegments_get
    if _newclass:numSegments = _swig_property(_lucenepp.IndexStatus_numSegments_get, _lucenepp.IndexStatus_numSegments_set)
    __swig_setmethods__["segmentFormat"] = _lucenepp.IndexStatus_segmentFormat_set
    __swig_getmethods__["segmentFormat"] = _lucenepp.IndexStatus_segmentFormat_get
    if _newclass:segmentFormat = _swig_property(_lucenepp.IndexStatus_segmentFormat_get, _lucenepp.IndexStatus_segmentFormat_set)
    __swig_setmethods__["segmentsChecked"] = _lucenepp.IndexStatus_segmentsChecked_set
    __swig_getmethods__["segmentsChecked"] = _lucenepp.IndexStatus_segmentsChecked_get
    if _newclass:segmentsChecked = _swig_property(_lucenepp.IndexStatus_segmentsChecked_get, _lucenepp.IndexStatus_segmentsChecked_set)
    __swig_setmethods__["toolOutOfDate"] = _lucenepp.IndexStatus_toolOutOfDate_set
    __swig_getmethods__["toolOutOfDate"] = _lucenepp.IndexStatus_toolOutOfDate_get
    if _newclass:toolOutOfDate = _swig_property(_lucenepp.IndexStatus_toolOutOfDate_get, _lucenepp.IndexStatus_toolOutOfDate_set)
    __swig_setmethods__["segmentInfos"] = _lucenepp.IndexStatus_segmentInfos_set
    __swig_getmethods__["segmentInfos"] = _lucenepp.IndexStatus_segmentInfos_get
    if _newclass:segmentInfos = _swig_property(_lucenepp.IndexStatus_segmentInfos_get, _lucenepp.IndexStatus_segmentInfos_set)
    __swig_setmethods__["dir"] = _lucenepp.IndexStatus_dir_set
    __swig_getmethods__["dir"] = _lucenepp.IndexStatus_dir_get
    if _newclass:dir = _swig_property(_lucenepp.IndexStatus_dir_get, _lucenepp.IndexStatus_dir_set)
    __swig_setmethods__["newSegments"] = _lucenepp.IndexStatus_newSegments_set
    __swig_getmethods__["newSegments"] = _lucenepp.IndexStatus_newSegments_get
    if _newclass:newSegments = _swig_property(_lucenepp.IndexStatus_newSegments_get, _lucenepp.IndexStatus_newSegments_set)
    __swig_setmethods__["totLoseDocCount"] = _lucenepp.IndexStatus_totLoseDocCount_set
    __swig_getmethods__["totLoseDocCount"] = _lucenepp.IndexStatus_totLoseDocCount_get
    if _newclass:totLoseDocCount = _swig_property(_lucenepp.IndexStatus_totLoseDocCount_get, _lucenepp.IndexStatus_totLoseDocCount_set)
    __swig_setmethods__["numBadSegments"] = _lucenepp.IndexStatus_numBadSegments_set
    __swig_getmethods__["numBadSegments"] = _lucenepp.IndexStatus_numBadSegments_get
    if _newclass:numBadSegments = _swig_property(_lucenepp.IndexStatus_numBadSegments_get, _lucenepp.IndexStatus_numBadSegments_set)
    __swig_setmethods__["partial"] = _lucenepp.IndexStatus_partial_set
    __swig_getmethods__["partial"] = _lucenepp.IndexStatus_partial_get
    if _newclass:partial = _swig_property(_lucenepp.IndexStatus_partial_get, _lucenepp.IndexStatus_partial_set)
    __swig_setmethods__["userData"] = _lucenepp.IndexStatus_userData_set
    __swig_getmethods__["userData"] = _lucenepp.IndexStatus_userData_get
    if _newclass:userData = _swig_property(_lucenepp.IndexStatus_userData_get, _lucenepp.IndexStatus_userData_set)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.IndexStatus___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.IndexStatus___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return IndexStatus.__cast_(obj)

IndexStatus_swigregister = _lucenepp.IndexStatus_swigregister
IndexStatus_swigregister(IndexStatus)

def IndexStatus___cast_(*args):
  return _lucenepp.IndexStatus___cast_(*args)
IndexStatus___cast_ = _lucenepp.IndexStatus___cast_

class FieldComparator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldComparator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FieldComparator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FieldComparator
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FieldComparator___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FieldComparator___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FieldComparator.__cast_(obj)

FieldComparator_swigregister = _lucenepp.FieldComparator_swigregister
FieldComparator_swigregister(FieldComparator)

def FieldComparator___cast_(*args):
  return _lucenepp.FieldComparator___cast_(*args)
FieldComparator___cast_ = _lucenepp.FieldComparator___cast_

class Query(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Query, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Query, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Query
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Query_getClassName(self)
    def setBoost(self, *args): return _lucenepp.Query_setBoost(self, *args)
    def getBoost(self): return _lucenepp.Query_getBoost(self)
    def toString(self, *args): return _lucenepp.Query_toString(self, *args)
    def createWeight(self, *args): return _lucenepp.Query_createWeight(self, *args)
    def weight(self, *args): return _lucenepp.Query_weight(self, *args)
    def rewrite(self, *args): return _lucenepp.Query_rewrite(self, *args)
    def combine(self, *args): return _lucenepp.Query_combine(self, *args)
    __swig_getmethods__["mergeBooleanQueries"] = lambda x: _lucenepp.Query_mergeBooleanQueries
    if _newclass:mergeBooleanQueries = staticmethod(_lucenepp.Query_mergeBooleanQueries)
    def getSimilarity(self, *args): return _lucenepp.Query_getSimilarity(self, *args)
    def boostString(self): return _lucenepp.Query_boostString(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Query___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Query___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Query.__cast_(obj)

Query_swigregister = _lucenepp.Query_swigregister
Query_swigregister(Query)

def Query_mergeBooleanQueries(*args):
  return _lucenepp.Query_mergeBooleanQueries(*args)
Query_mergeBooleanQueries = _lucenepp.Query_mergeBooleanQueries

def Query___cast_(*args):
  return _lucenepp.Query___cast_(*args)
Query___cast_ = _lucenepp.Query___cast_

class Filter(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Filter, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Filter, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Filter
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Filter_getClassName(self)
    def getDocIdSet(self, *args): return _lucenepp.Filter_getDocIdSet(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Filter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Filter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Filter.__cast_(obj)

    def __init__(self): 
        if self.__class__ == Filter:
            _self = None
        else:
            _self = self
        this = _lucenepp.new_Filter(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _lucenepp.disown_Filter(self)
        return weakref_proxy(self)
Filter_swigregister = _lucenepp.Filter_swigregister
Filter_swigregister(Filter)

def Filter___cast_(*args):
  return _lucenepp.Filter___cast_(*args)
Filter___cast_ = _lucenepp.Filter___cast_

class Explanation(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Explanation, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Explanation, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_Explanation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Explanation
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Explanation_getClassName(self)
    def isMatch(self): return _lucenepp.Explanation_isMatch(self)
    def getValue(self): return _lucenepp.Explanation_getValue(self)
    def setValue(self, *args): return _lucenepp.Explanation_setValue(self, *args)
    def getDescription(self): return _lucenepp.Explanation_getDescription(self)
    def setDescription(self, *args): return _lucenepp.Explanation_setDescription(self, *args)
    def getDetails(self): return _lucenepp.Explanation_getDetails(self)
    def addDetail(self, *args): return _lucenepp.Explanation_addDetail(self, *args)
    def toHtml(self): return _lucenepp.Explanation_toHtml(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Explanation___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Explanation___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Explanation.__cast_(obj)

Explanation_swigregister = _lucenepp.Explanation_swigregister
Explanation_swigregister(Explanation)

def Explanation___cast_(*args):
  return _lucenepp.Explanation___cast_(*args)
Explanation___cast_ = _lucenepp.Explanation___cast_

class Similarity(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Similarity, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Similarity, name)
    __repr__ = _swig_repr
    def __init__(self): 
        if self.__class__ == Similarity:
            _self = None
        else:
            _self = self
        this = _lucenepp.new_Similarity(_self, )
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Similarity
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Similarity_getClassName(self)
    __swig_getmethods__["getDefault"] = lambda x: _lucenepp.Similarity_getDefault
    if _newclass:getDefault = staticmethod(_lucenepp.Similarity_getDefault)
    __swig_getmethods__["decodeNorm"] = lambda x: _lucenepp.Similarity_decodeNorm
    if _newclass:decodeNorm = staticmethod(_lucenepp.Similarity_decodeNorm)
    __swig_getmethods__["getNormDecoder"] = lambda x: _lucenepp.Similarity_getNormDecoder
    if _newclass:getNormDecoder = staticmethod(_lucenepp.Similarity_getNormDecoder)
    def computeNorm(self, *args): return _lucenepp.Similarity_computeNorm(self, *args)
    def lengthNorm(self, *args): return _lucenepp.Similarity_lengthNorm(self, *args)
    def queryNorm(self, *args): return _lucenepp.Similarity_queryNorm(self, *args)
    __swig_getmethods__["encodeNorm"] = lambda x: _lucenepp.Similarity_encodeNorm
    if _newclass:encodeNorm = staticmethod(_lucenepp.Similarity_encodeNorm)
    def sloppyFreq(self, *args): return _lucenepp.Similarity_sloppyFreq(self, *args)
    def tf(self, *args): return _lucenepp.Similarity_tf(self, *args)
    def idf(self, *args): return _lucenepp.Similarity_idf(self, *args)
    def coord(self, *args): return _lucenepp.Similarity_coord(self, *args)
    def scorePayload(self, *args): return _lucenepp.Similarity_scorePayload(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Similarity___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Similarity___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Similarity.__cast_(obj)

    def __disown__(self):
        self.this.disown()
        _lucenepp.disown_Similarity(self)
        return weakref_proxy(self)
Similarity_swigregister = _lucenepp.Similarity_swigregister
Similarity_swigregister(Similarity)

def Similarity_getDefault():
  return _lucenepp.Similarity_getDefault()
Similarity_getDefault = _lucenepp.Similarity_getDefault

def Similarity_decodeNorm(*args):
  return _lucenepp.Similarity_decodeNorm(*args)
Similarity_decodeNorm = _lucenepp.Similarity_decodeNorm

def Similarity_getNormDecoder():
  return _lucenepp.Similarity_getNormDecoder()
Similarity_getNormDecoder = _lucenepp.Similarity_getNormDecoder

def Similarity_encodeNorm(*args):
  return _lucenepp.Similarity_encodeNorm(*args)
Similarity_encodeNorm = _lucenepp.Similarity_encodeNorm

def Similarity___cast_(*args):
  return _lucenepp.Similarity___cast_(*args)
Similarity___cast_ = _lucenepp.Similarity___cast_

class DocIdSetIterator(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DocIdSetIterator, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DocIdSetIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_DocIdSetIterator
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.DocIdSetIterator_getClassName(self)
    def docID(self): return _lucenepp.DocIdSetIterator_docID(self)
    def nextDoc(self): return _lucenepp.DocIdSetIterator_nextDoc(self)
    def advance(self, *args): return _lucenepp.DocIdSetIterator_advance(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.DocIdSetIterator___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.DocIdSetIterator___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return DocIdSetIterator.__cast_(obj)

DocIdSetIterator_swigregister = _lucenepp.DocIdSetIterator_swigregister
DocIdSetIterator_swigregister(DocIdSetIterator)
DocIdSetIterator.NO_MORE_DOCS = _lucenepp.cvar.DocIdSetIterator_NO_MORE_DOCS

def DocIdSetIterator___cast_(*args):
  return _lucenepp.DocIdSetIterator___cast_(*args)
DocIdSetIterator___cast_ = _lucenepp.DocIdSetIterator___cast_

class Scorer(DocIdSetIterator):
    __swig_setmethods__ = {}
    for _s in [DocIdSetIterator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scorer, name, value)
    __swig_getmethods__ = {}
    for _s in [DocIdSetIterator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Scorer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Scorer
    __del__ = lambda self : None;
    def getSimilarity(self): return _lucenepp.Scorer_getSimilarity(self)
    def score(self, *args): return _lucenepp.Scorer_score(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Scorer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Scorer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Scorer.__cast_(obj)

Scorer_swigregister = _lucenepp.Scorer_swigregister
Scorer_swigregister(Scorer)

def Scorer___cast_(*args):
  return _lucenepp.Scorer___cast_(*args)
Scorer___cast_ = _lucenepp.Scorer___cast_

class Searchable(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Searchable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Searchable, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassName(self): return _lucenepp.Searchable_getClassName(self)
    def close(self): return _lucenepp.Searchable_close(self)
    def docFreq(self, *args): return _lucenepp.Searchable_docFreq(self, *args)
    def docFreqs(self, *args): return _lucenepp.Searchable_docFreqs(self, *args)
    def maxDoc(self): return _lucenepp.Searchable_maxDoc(self)
    def doc(self, *args): return _lucenepp.Searchable_doc(self, *args)
    def rewrite(self, *args): return _lucenepp.Searchable_rewrite(self, *args)
    def explain(self, *args): return _lucenepp.Searchable_explain(self, *args)
    def search(self, *args): return _lucenepp.Searchable_search(self, *args)
    def toLuceneObject__(self, *args): return _lucenepp.Searchable_toLuceneObject__(self, *args)
    def toLuceneObject(self): return self.toLuceneObject__(self)

    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Searchable___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Searchable___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Searchable.__cast_(obj)

    __swig_destroy__ = _lucenepp.delete_Searchable
    __del__ = lambda self : None;
Searchable_swigregister = _lucenepp.Searchable_swigregister
Searchable_swigregister(Searchable)

def Searchable___cast_(*args):
  return _lucenepp.Searchable___cast_(*args)
Searchable___cast_ = _lucenepp.Searchable___cast_

class Searcher(Searchable,LuceneObject):
    __swig_setmethods__ = {}
    for _s in [Searchable,LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Searcher, name, value)
    __swig_getmethods__ = {}
    for _s in [Searchable,LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Searcher, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Searcher
    __del__ = lambda self : None;
    def setSimilarity(self, *args): return _lucenepp.Searcher_setSimilarity(self, *args)
    def getSimilarity(self): return _lucenepp.Searcher_getSimilarity(self)
    def doc(self, *args): return _lucenepp.Searcher_doc(self, *args)
    def explain(self, *args): return _lucenepp.Searcher_explain(self, *args)
    def search(self, *args): return _lucenepp.Searcher_search(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Searcher___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Searcher___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Searcher.__cast_(obj)

Searcher_swigregister = _lucenepp.Searcher_swigregister
Searcher_swigregister(Searcher)

def Searcher___cast_(*args):
  return _lucenepp.Searcher___cast_(*args)
Searcher___cast_ = _lucenepp.Searcher___cast_

class SpanWeight(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanWeight, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SpanWeight, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SpanWeight(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SpanWeight
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.SpanWeight_getClassName(self)
    def getQuery(self): return _lucenepp.SpanWeight_getQuery(self)
    def getValue(self): return _lucenepp.SpanWeight_getValue(self)
    def sumOfSquaredWeights(self): return _lucenepp.SpanWeight_sumOfSquaredWeights(self)
    def normalize(self, *args): return _lucenepp.SpanWeight_normalize(self, *args)
    def scorer(self, *args): return _lucenepp.SpanWeight_scorer(self, *args)
    def explain(self, *args): return _lucenepp.SpanWeight_explain(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanWeight___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanWeight___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanWeight.__cast_(obj)

SpanWeight_swigregister = _lucenepp.SpanWeight_swigregister
SpanWeight_swigregister(SpanWeight)

def SpanWeight___cast_(*args):
  return _lucenepp.SpanWeight___cast_(*args)
SpanWeight___cast_ = _lucenepp.SpanWeight___cast_

class TermQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TermQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_TermQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_TermQuery
    __del__ = lambda self : None;
    def getTerm(self): return _lucenepp.TermQuery_getTerm(self)
    def toString(self, *args): return _lucenepp.TermQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermQuery.__cast_(obj)

TermQuery_swigregister = _lucenepp.TermQuery_swigregister
TermQuery_swigregister(TermQuery)

def TermQuery___cast_(*args):
  return _lucenepp.TermQuery___cast_(*args)
TermQuery___cast_ = _lucenepp.TermQuery___cast_

class ScoreDoc(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScoreDoc, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScoreDoc, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_ScoreDoc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_ScoreDoc
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.ScoreDoc_getClassName(self)
    __swig_setmethods__["score"] = _lucenepp.ScoreDoc_score_set
    __swig_getmethods__["score"] = _lucenepp.ScoreDoc_score_get
    if _newclass:score = _swig_property(_lucenepp.ScoreDoc_score_get, _lucenepp.ScoreDoc_score_set)
    __swig_setmethods__["doc"] = _lucenepp.ScoreDoc_doc_set
    __swig_getmethods__["doc"] = _lucenepp.ScoreDoc_doc_get
    if _newclass:doc = _swig_property(_lucenepp.ScoreDoc_doc_get, _lucenepp.ScoreDoc_doc_set)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.ScoreDoc___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.ScoreDoc___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return ScoreDoc.__cast_(obj)

ScoreDoc_swigregister = _lucenepp.ScoreDoc_swigregister
ScoreDoc_swigregister(ScoreDoc)

def ScoreDoc___cast_(*args):
  return _lucenepp.ScoreDoc___cast_(*args)
ScoreDoc___cast_ = _lucenepp.ScoreDoc___cast_

class MultiTermQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiTermQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiTermQuery, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_MultiTermQuery
    __del__ = lambda self : None;
    __swig_getmethods__["CONSTANT_SCORE_FILTER_REWRITE"] = lambda x: _lucenepp.MultiTermQuery_CONSTANT_SCORE_FILTER_REWRITE
    if _newclass:CONSTANT_SCORE_FILTER_REWRITE = staticmethod(_lucenepp.MultiTermQuery_CONSTANT_SCORE_FILTER_REWRITE)
    __swig_getmethods__["SCORING_BOOLEAN_QUERY_REWRITE"] = lambda x: _lucenepp.MultiTermQuery_SCORING_BOOLEAN_QUERY_REWRITE
    if _newclass:SCORING_BOOLEAN_QUERY_REWRITE = staticmethod(_lucenepp.MultiTermQuery_SCORING_BOOLEAN_QUERY_REWRITE)
    __swig_getmethods__["CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE"] = lambda x: _lucenepp.MultiTermQuery_CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE
    if _newclass:CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE = staticmethod(_lucenepp.MultiTermQuery_CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE)
    __swig_getmethods__["CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"] = lambda x: _lucenepp.MultiTermQuery_CONSTANT_SCORE_AUTO_REWRITE_DEFAULT
    if _newclass:CONSTANT_SCORE_AUTO_REWRITE_DEFAULT = staticmethod(_lucenepp.MultiTermQuery_CONSTANT_SCORE_AUTO_REWRITE_DEFAULT)
    def getTotalNumberOfTerms(self): return _lucenepp.MultiTermQuery_getTotalNumberOfTerms(self)
    def clearTotalNumberOfTerms(self): return _lucenepp.MultiTermQuery_clearTotalNumberOfTerms(self)
    def getRewriteMethod(self): return _lucenepp.MultiTermQuery_getRewriteMethod(self)
    def setRewriteMethod(self, *args): return _lucenepp.MultiTermQuery_setRewriteMethod(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.MultiTermQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.MultiTermQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return MultiTermQuery.__cast_(obj)

MultiTermQuery_swigregister = _lucenepp.MultiTermQuery_swigregister
MultiTermQuery_swigregister(MultiTermQuery)

def MultiTermQuery_CONSTANT_SCORE_FILTER_REWRITE():
  return _lucenepp.MultiTermQuery_CONSTANT_SCORE_FILTER_REWRITE()
MultiTermQuery_CONSTANT_SCORE_FILTER_REWRITE = _lucenepp.MultiTermQuery_CONSTANT_SCORE_FILTER_REWRITE

def MultiTermQuery_SCORING_BOOLEAN_QUERY_REWRITE():
  return _lucenepp.MultiTermQuery_SCORING_BOOLEAN_QUERY_REWRITE()
MultiTermQuery_SCORING_BOOLEAN_QUERY_REWRITE = _lucenepp.MultiTermQuery_SCORING_BOOLEAN_QUERY_REWRITE

def MultiTermQuery_CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE():
  return _lucenepp.MultiTermQuery_CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE()
MultiTermQuery_CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE = _lucenepp.MultiTermQuery_CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE

def MultiTermQuery_CONSTANT_SCORE_AUTO_REWRITE_DEFAULT():
  return _lucenepp.MultiTermQuery_CONSTANT_SCORE_AUTO_REWRITE_DEFAULT()
MultiTermQuery_CONSTANT_SCORE_AUTO_REWRITE_DEFAULT = _lucenepp.MultiTermQuery_CONSTANT_SCORE_AUTO_REWRITE_DEFAULT

def MultiTermQuery___cast_(*args):
  return _lucenepp.MultiTermQuery___cast_(*args)
MultiTermQuery___cast_ = _lucenepp.MultiTermQuery___cast_

class BooleanClause(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BooleanClause, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BooleanClause, name)
    __repr__ = _swig_repr
    MUST = _lucenepp.BooleanClause_MUST
    SHOULD = _lucenepp.BooleanClause_SHOULD
    MUST_NOT = _lucenepp.BooleanClause_MUST_NOT
    def __init__(self, *args): 
        this = _lucenepp.new_BooleanClause(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_BooleanClause
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.BooleanClause_getClassName(self)
    def getOccur(self): return _lucenepp.BooleanClause_getOccur(self)
    def setOccur(self, *args): return _lucenepp.BooleanClause_setOccur(self, *args)
    def getQuery(self): return _lucenepp.BooleanClause_getQuery(self)
    def setQuery(self, *args): return _lucenepp.BooleanClause_setQuery(self, *args)
    def isProhibited(self): return _lucenepp.BooleanClause_isProhibited(self)
    def isRequired(self): return _lucenepp.BooleanClause_isRequired(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.BooleanClause___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.BooleanClause___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return BooleanClause.__cast_(obj)

BooleanClause_swigregister = _lucenepp.BooleanClause_swigregister
BooleanClause_swigregister(BooleanClause)

def BooleanClause___cast_(*args):
  return _lucenepp.BooleanClause___cast_(*args)
BooleanClause___cast_ = _lucenepp.BooleanClause___cast_

class BooleanQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BooleanQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BooleanQuery, name)
    __repr__ = _swig_repr
    def __init__(self, disableCoord = False): 
        this = _lucenepp.new_BooleanQuery(disableCoord)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_BooleanQuery
    __del__ = lambda self : None;
    __swig_getmethods__["getMaxClauseCount"] = lambda x: _lucenepp.BooleanQuery_getMaxClauseCount
    if _newclass:getMaxClauseCount = staticmethod(_lucenepp.BooleanQuery_getMaxClauseCount)
    __swig_getmethods__["setMaxClauseCount"] = lambda x: _lucenepp.BooleanQuery_setMaxClauseCount
    if _newclass:setMaxClauseCount = staticmethod(_lucenepp.BooleanQuery_setMaxClauseCount)
    def isCoordDisabled(self): return _lucenepp.BooleanQuery_isCoordDisabled(self)
    def setMinimumNumberShouldMatch(self, *args): return _lucenepp.BooleanQuery_setMinimumNumberShouldMatch(self, *args)
    def getMinimumNumberShouldMatch(self): return _lucenepp.BooleanQuery_getMinimumNumberShouldMatch(self)
    def add(self, *args): return _lucenepp.BooleanQuery_add(self, *args)
    def getClauses(self): return _lucenepp.BooleanQuery_getClauses(self)
    def toString(self, *args): return _lucenepp.BooleanQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.BooleanQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.BooleanQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return BooleanQuery.__cast_(obj)

BooleanQuery_swigregister = _lucenepp.BooleanQuery_swigregister
BooleanQuery_swigregister(BooleanQuery)

def BooleanQuery_getMaxClauseCount():
  return _lucenepp.BooleanQuery_getMaxClauseCount()
BooleanQuery_getMaxClauseCount = _lucenepp.BooleanQuery_getMaxClauseCount

def BooleanQuery_setMaxClauseCount(*args):
  return _lucenepp.BooleanQuery_setMaxClauseCount(*args)
BooleanQuery_setMaxClauseCount = _lucenepp.BooleanQuery_setMaxClauseCount

def BooleanQuery___cast_(*args):
  return _lucenepp.BooleanQuery___cast_(*args)
BooleanQuery___cast_ = _lucenepp.BooleanQuery___cast_

class CachingWrapperFilter(Filter):
    __swig_setmethods__ = {}
    for _s in [Filter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CachingWrapperFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [Filter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CachingWrapperFilter, name)
    __repr__ = _swig_repr
    DELETES_IGNORE = _lucenepp.CachingWrapperFilter_DELETES_IGNORE
    DELETES_RECACHE = _lucenepp.CachingWrapperFilter_DELETES_RECACHE
    DELETES_DYNAMIC = _lucenepp.CachingWrapperFilter_DELETES_DYNAMIC
    def __init__(self, *args): 
        this = _lucenepp.new_CachingWrapperFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_CachingWrapperFilter
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.CachingWrapperFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.CachingWrapperFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return CachingWrapperFilter.__cast_(obj)

CachingWrapperFilter_swigregister = _lucenepp.CachingWrapperFilter_swigregister
CachingWrapperFilter_swigregister(CachingWrapperFilter)

def CachingWrapperFilter___cast_(*args):
  return _lucenepp.CachingWrapperFilter___cast_(*args)
CachingWrapperFilter___cast_ = _lucenepp.CachingWrapperFilter___cast_

class Collector(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Collector, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Collector, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Collector
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Collector_getClassName(self)
    def setScorer(self, *args): return _lucenepp.Collector_setScorer(self, *args)
    def collect(self, *args): return _lucenepp.Collector_collect(self, *args)
    def setNextReader(self, *args): return _lucenepp.Collector_setNextReader(self, *args)
    def acceptsDocsOutOfOrder(self): return _lucenepp.Collector_acceptsDocsOutOfOrder(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Collector___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Collector___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Collector.__cast_(obj)

    def __init__(self): 
        if self.__class__ == Collector:
            _self = None
        else:
            _self = self
        this = _lucenepp.new_Collector(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _lucenepp.disown_Collector(self)
        return weakref_proxy(self)
Collector_swigregister = _lucenepp.Collector_swigregister
Collector_swigregister(Collector)

def Collector___cast_(*args):
  return _lucenepp.Collector___cast_(*args)
Collector___cast_ = _lucenepp.Collector___cast_

class ConstantScoreQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConstantScoreQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConstantScoreQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_ConstantScoreQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_ConstantScoreQuery
    __del__ = lambda self : None;
    def getFilter(self): return _lucenepp.ConstantScoreQuery_getFilter(self)
    def toString(self, *args): return _lucenepp.ConstantScoreQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.ConstantScoreQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.ConstantScoreQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return ConstantScoreQuery.__cast_(obj)

ConstantScoreQuery_swigregister = _lucenepp.ConstantScoreQuery_swigregister
ConstantScoreQuery_swigregister(ConstantScoreQuery)

def ConstantScoreQuery___cast_(*args):
  return _lucenepp.ConstantScoreQuery___cast_(*args)
ConstantScoreQuery___cast_ = _lucenepp.ConstantScoreQuery___cast_

class DisjunctionMaxQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DisjunctionMaxQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DisjunctionMaxQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_DisjunctionMaxQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_DisjunctionMaxQuery
    __del__ = lambda self : None;
    def add(self, *args): return _lucenepp.DisjunctionMaxQuery_add(self, *args)
    def toString(self, *args): return _lucenepp.DisjunctionMaxQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.DisjunctionMaxQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.DisjunctionMaxQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return DisjunctionMaxQuery.__cast_(obj)

DisjunctionMaxQuery_swigregister = _lucenepp.DisjunctionMaxQuery_swigregister
DisjunctionMaxQuery_swigregister(DisjunctionMaxQuery)

def DisjunctionMaxQuery___cast_(*args):
  return _lucenepp.DisjunctionMaxQuery___cast_(*args)
DisjunctionMaxQuery___cast_ = _lucenepp.DisjunctionMaxQuery___cast_

class DocIdSet(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DocIdSet, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DocIdSet, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_DocIdSet
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.DocIdSet_getClassName(self)
    def iterator(self): return _lucenepp.DocIdSet_iterator(self)
    def isCacheable(self): return _lucenepp.DocIdSet_isCacheable(self)
    __swig_getmethods__["EMPTY_DOCIDSET"] = lambda x: _lucenepp.DocIdSet_EMPTY_DOCIDSET
    if _newclass:EMPTY_DOCIDSET = staticmethod(_lucenepp.DocIdSet_EMPTY_DOCIDSET)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.DocIdSet___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.DocIdSet___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return DocIdSet.__cast_(obj)

DocIdSet_swigregister = _lucenepp.DocIdSet_swigregister
DocIdSet_swigregister(DocIdSet)

def DocIdSet_EMPTY_DOCIDSET():
  return _lucenepp.DocIdSet_EMPTY_DOCIDSET()
DocIdSet_EMPTY_DOCIDSET = _lucenepp.DocIdSet_EMPTY_DOCIDSET

def DocIdSet___cast_(*args):
  return _lucenepp.DocIdSet___cast_(*args)
DocIdSet___cast_ = _lucenepp.DocIdSet___cast_

class FieldCache(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldCache, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FieldCache, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FieldCache
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.FieldCache_getClassName(self)
    CACHE_BYTE = _lucenepp.FieldCache_CACHE_BYTE
    CACHE_INT = _lucenepp.FieldCache_CACHE_INT
    CACHE_LONG = _lucenepp.FieldCache_CACHE_LONG
    CACHE_DOUBLE = _lucenepp.FieldCache_CACHE_DOUBLE
    CACHE_STRING = _lucenepp.FieldCache_CACHE_STRING
    CACHE_STRING_INDEX = _lucenepp.FieldCache_CACHE_STRING_INDEX
    __swig_getmethods__["DEFAULT"] = lambda x: _lucenepp.FieldCache_DEFAULT
    if _newclass:DEFAULT = staticmethod(_lucenepp.FieldCache_DEFAULT)
    __swig_getmethods__["DEFAULT_BYTE_PARSER"] = lambda x: _lucenepp.FieldCache_DEFAULT_BYTE_PARSER
    if _newclass:DEFAULT_BYTE_PARSER = staticmethod(_lucenepp.FieldCache_DEFAULT_BYTE_PARSER)
    __swig_getmethods__["DEFAULT_INT_PARSER"] = lambda x: _lucenepp.FieldCache_DEFAULT_INT_PARSER
    if _newclass:DEFAULT_INT_PARSER = staticmethod(_lucenepp.FieldCache_DEFAULT_INT_PARSER)
    __swig_getmethods__["DEFAULT_LONG_PARSER"] = lambda x: _lucenepp.FieldCache_DEFAULT_LONG_PARSER
    if _newclass:DEFAULT_LONG_PARSER = staticmethod(_lucenepp.FieldCache_DEFAULT_LONG_PARSER)
    __swig_getmethods__["DEFAULT_DOUBLE_PARSER"] = lambda x: _lucenepp.FieldCache_DEFAULT_DOUBLE_PARSER
    if _newclass:DEFAULT_DOUBLE_PARSER = staticmethod(_lucenepp.FieldCache_DEFAULT_DOUBLE_PARSER)
    __swig_getmethods__["NUMERIC_UTILS_INT_PARSER"] = lambda x: _lucenepp.FieldCache_NUMERIC_UTILS_INT_PARSER
    if _newclass:NUMERIC_UTILS_INT_PARSER = staticmethod(_lucenepp.FieldCache_NUMERIC_UTILS_INT_PARSER)
    __swig_getmethods__["NUMERIC_UTILS_LONG_PARSER"] = lambda x: _lucenepp.FieldCache_NUMERIC_UTILS_LONG_PARSER
    if _newclass:NUMERIC_UTILS_LONG_PARSER = staticmethod(_lucenepp.FieldCache_NUMERIC_UTILS_LONG_PARSER)
    __swig_getmethods__["NUMERIC_UTILS_DOUBLE_PARSER"] = lambda x: _lucenepp.FieldCache_NUMERIC_UTILS_DOUBLE_PARSER
    if _newclass:NUMERIC_UTILS_DOUBLE_PARSER = staticmethod(_lucenepp.FieldCache_NUMERIC_UTILS_DOUBLE_PARSER)
    def getInts(self, *args): return _lucenepp.FieldCache_getInts(self, *args)
    def getDoubles(self, *args): return _lucenepp.FieldCache_getDoubles(self, *args)
    def getStrings(self, *args): return _lucenepp.FieldCache_getStrings(self, *args)
    def getStringIndex(self, *args): return _lucenepp.FieldCache_getStringIndex(self, *args)
    def getCacheEntries(self): return _lucenepp.FieldCache_getCacheEntries(self)
    def purgeAllCaches(self): return _lucenepp.FieldCache_purgeAllCaches(self)
    def purge(self, *args): return _lucenepp.FieldCache_purge(self, *args)
    def setInfoStream(self, *args): return _lucenepp.FieldCache_setInfoStream(self, *args)
    def getInfoStream(self): return _lucenepp.FieldCache_getInfoStream(self)
    def toLuceneObject__(self, *args): return _lucenepp.FieldCache_toLuceneObject__(self, *args)
    def toLuceneObject(self): return self.toLuceneObject__(self)

    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FieldCache___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FieldCache___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FieldCache.__cast_(obj)

FieldCache_swigregister = _lucenepp.FieldCache_swigregister
FieldCache_swigregister(FieldCache)
FieldCache.STRING_INDEX = _lucenepp.cvar.FieldCache_STRING_INDEX

def FieldCache_DEFAULT():
  return _lucenepp.FieldCache_DEFAULT()
FieldCache_DEFAULT = _lucenepp.FieldCache_DEFAULT

def FieldCache_DEFAULT_BYTE_PARSER():
  return _lucenepp.FieldCache_DEFAULT_BYTE_PARSER()
FieldCache_DEFAULT_BYTE_PARSER = _lucenepp.FieldCache_DEFAULT_BYTE_PARSER

def FieldCache_DEFAULT_INT_PARSER():
  return _lucenepp.FieldCache_DEFAULT_INT_PARSER()
FieldCache_DEFAULT_INT_PARSER = _lucenepp.FieldCache_DEFAULT_INT_PARSER

def FieldCache_DEFAULT_LONG_PARSER():
  return _lucenepp.FieldCache_DEFAULT_LONG_PARSER()
FieldCache_DEFAULT_LONG_PARSER = _lucenepp.FieldCache_DEFAULT_LONG_PARSER

def FieldCache_DEFAULT_DOUBLE_PARSER():
  return _lucenepp.FieldCache_DEFAULT_DOUBLE_PARSER()
FieldCache_DEFAULT_DOUBLE_PARSER = _lucenepp.FieldCache_DEFAULT_DOUBLE_PARSER

def FieldCache_NUMERIC_UTILS_INT_PARSER():
  return _lucenepp.FieldCache_NUMERIC_UTILS_INT_PARSER()
FieldCache_NUMERIC_UTILS_INT_PARSER = _lucenepp.FieldCache_NUMERIC_UTILS_INT_PARSER

def FieldCache_NUMERIC_UTILS_LONG_PARSER():
  return _lucenepp.FieldCache_NUMERIC_UTILS_LONG_PARSER()
FieldCache_NUMERIC_UTILS_LONG_PARSER = _lucenepp.FieldCache_NUMERIC_UTILS_LONG_PARSER

def FieldCache_NUMERIC_UTILS_DOUBLE_PARSER():
  return _lucenepp.FieldCache_NUMERIC_UTILS_DOUBLE_PARSER()
FieldCache_NUMERIC_UTILS_DOUBLE_PARSER = _lucenepp.FieldCache_NUMERIC_UTILS_DOUBLE_PARSER

def FieldCache___cast_(*args):
  return _lucenepp.FieldCache___cast_(*args)
FieldCache___cast_ = _lucenepp.FieldCache___cast_

class ByteParser(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ByteParser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ByteParser, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_ByteParser
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.ByteParser_getClassName(self)
    def parseByte(self, *args): return _lucenepp.ByteParser_parseByte(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.ByteParser___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.ByteParser___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return ByteParser.__cast_(obj)

    def __init__(self): 
        this = _lucenepp.new_ByteParser()
        try: self.this.append(this)
        except: self.this = this
ByteParser_swigregister = _lucenepp.ByteParser_swigregister
ByteParser_swigregister(ByteParser)

def ByteParser___cast_(*args):
  return _lucenepp.ByteParser___cast_(*args)
ByteParser___cast_ = _lucenepp.ByteParser___cast_

class IntParser(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntParser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntParser, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_IntParser
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.IntParser_getClassName(self)
    def parseInt(self, *args): return _lucenepp.IntParser_parseInt(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.IntParser___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.IntParser___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return IntParser.__cast_(obj)

    def __init__(self): 
        this = _lucenepp.new_IntParser()
        try: self.this.append(this)
        except: self.this = this
IntParser_swigregister = _lucenepp.IntParser_swigregister
IntParser_swigregister(IntParser)

def IntParser___cast_(*args):
  return _lucenepp.IntParser___cast_(*args)
IntParser___cast_ = _lucenepp.IntParser___cast_

class LongParser(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LongParser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LongParser, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_LongParser
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.LongParser_getClassName(self)
    def parseLong(self, *args): return _lucenepp.LongParser_parseLong(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.LongParser___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.LongParser___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return LongParser.__cast_(obj)

    def __init__(self): 
        this = _lucenepp.new_LongParser()
        try: self.this.append(this)
        except: self.this = this
LongParser_swigregister = _lucenepp.LongParser_swigregister
LongParser_swigregister(LongParser)

def LongParser___cast_(*args):
  return _lucenepp.LongParser___cast_(*args)
LongParser___cast_ = _lucenepp.LongParser___cast_

class DoubleParser(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleParser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleParser, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_DoubleParser
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.DoubleParser_getClassName(self)
    def parseDouble(self, *args): return _lucenepp.DoubleParser_parseDouble(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.DoubleParser___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.DoubleParser___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return DoubleParser.__cast_(obj)

    def __init__(self): 
        this = _lucenepp.new_DoubleParser()
        try: self.this.append(this)
        except: self.this = this
DoubleParser_swigregister = _lucenepp.DoubleParser_swigregister
DoubleParser_swigregister(DoubleParser)

def DoubleParser___cast_(*args):
  return _lucenepp.DoubleParser___cast_(*args)
DoubleParser___cast_ = _lucenepp.DoubleParser___cast_

class FieldCacheRangeFilter(Filter):
    __swig_setmethods__ = {}
    for _s in [Filter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldCacheRangeFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [Filter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FieldCacheRangeFilter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FieldCacheRangeFilter
    __del__ = lambda self : None;
    __swig_getmethods__["newStringRange"] = lambda x: _lucenepp.FieldCacheRangeFilter_newStringRange
    if _newclass:newStringRange = staticmethod(_lucenepp.FieldCacheRangeFilter_newStringRange)
    __swig_getmethods__["newByteRange"] = lambda x: _lucenepp.FieldCacheRangeFilter_newByteRange
    if _newclass:newByteRange = staticmethod(_lucenepp.FieldCacheRangeFilter_newByteRange)
    __swig_getmethods__["newIntRange"] = lambda x: _lucenepp.FieldCacheRangeFilter_newIntRange
    if _newclass:newIntRange = staticmethod(_lucenepp.FieldCacheRangeFilter_newIntRange)
    __swig_getmethods__["newLongRange"] = lambda x: _lucenepp.FieldCacheRangeFilter_newLongRange
    if _newclass:newLongRange = staticmethod(_lucenepp.FieldCacheRangeFilter_newLongRange)
    __swig_getmethods__["newDoubleRange"] = lambda x: _lucenepp.FieldCacheRangeFilter_newDoubleRange
    if _newclass:newDoubleRange = staticmethod(_lucenepp.FieldCacheRangeFilter_newDoubleRange)
    def getField(self): return _lucenepp.FieldCacheRangeFilter_getField(self)
    def includesLower(self): return _lucenepp.FieldCacheRangeFilter_includesLower(self)
    def includesUpper(self): return _lucenepp.FieldCacheRangeFilter_includesUpper(self)
    def getParser(self): return _lucenepp.FieldCacheRangeFilter_getParser(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FieldCacheRangeFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FieldCacheRangeFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FieldCacheRangeFilter.__cast_(obj)

FieldCacheRangeFilter_swigregister = _lucenepp.FieldCacheRangeFilter_swigregister
FieldCacheRangeFilter_swigregister(FieldCacheRangeFilter)

def FieldCacheRangeFilter_newStringRange(*args):
  return _lucenepp.FieldCacheRangeFilter_newStringRange(*args)
FieldCacheRangeFilter_newStringRange = _lucenepp.FieldCacheRangeFilter_newStringRange

def FieldCacheRangeFilter_newByteRange(*args):
  return _lucenepp.FieldCacheRangeFilter_newByteRange(*args)
FieldCacheRangeFilter_newByteRange = _lucenepp.FieldCacheRangeFilter_newByteRange

def FieldCacheRangeFilter_newIntRange(*args):
  return _lucenepp.FieldCacheRangeFilter_newIntRange(*args)
FieldCacheRangeFilter_newIntRange = _lucenepp.FieldCacheRangeFilter_newIntRange

def FieldCacheRangeFilter_newLongRange(*args):
  return _lucenepp.FieldCacheRangeFilter_newLongRange(*args)
FieldCacheRangeFilter_newLongRange = _lucenepp.FieldCacheRangeFilter_newLongRange

def FieldCacheRangeFilter_newDoubleRange(*args):
  return _lucenepp.FieldCacheRangeFilter_newDoubleRange(*args)
FieldCacheRangeFilter_newDoubleRange = _lucenepp.FieldCacheRangeFilter_newDoubleRange

def FieldCacheRangeFilter___cast_(*args):
  return _lucenepp.FieldCacheRangeFilter___cast_(*args)
FieldCacheRangeFilter___cast_ = _lucenepp.FieldCacheRangeFilter___cast_

class FieldCacheTermsFilter(Filter):
    __swig_setmethods__ = {}
    for _s in [Filter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldCacheTermsFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [Filter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FieldCacheTermsFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_FieldCacheTermsFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_FieldCacheTermsFilter
    __del__ = lambda self : None;
    def getFieldCache(self): return _lucenepp.FieldCacheTermsFilter_getFieldCache(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FieldCacheTermsFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FieldCacheTermsFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FieldCacheTermsFilter.__cast_(obj)

FieldCacheTermsFilter_swigregister = _lucenepp.FieldCacheTermsFilter_swigregister
FieldCacheTermsFilter_swigregister(FieldCacheTermsFilter)

def FieldCacheTermsFilter___cast_(*args):
  return _lucenepp.FieldCacheTermsFilter___cast_(*args)
FieldCacheTermsFilter___cast_ = _lucenepp.FieldCacheTermsFilter___cast_

class FilteredDocIdSet(DocIdSet):
    __swig_setmethods__ = {}
    for _s in [DocIdSet]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FilteredDocIdSet, name, value)
    __swig_getmethods__ = {}
    for _s in [DocIdSet]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FilteredDocIdSet, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FilteredDocIdSet
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FilteredDocIdSet___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FilteredDocIdSet___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FilteredDocIdSet.__cast_(obj)

FilteredDocIdSet_swigregister = _lucenepp.FilteredDocIdSet_swigregister
FilteredDocIdSet_swigregister(FilteredDocIdSet)

def FilteredDocIdSet___cast_(*args):
  return _lucenepp.FilteredDocIdSet___cast_(*args)
FilteredDocIdSet___cast_ = _lucenepp.FilteredDocIdSet___cast_

class FilteredDocIdSetIterator(DocIdSetIterator):
    __swig_setmethods__ = {}
    for _s in [DocIdSetIterator]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FilteredDocIdSetIterator, name, value)
    __swig_getmethods__ = {}
    for _s in [DocIdSetIterator]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FilteredDocIdSetIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FilteredDocIdSetIterator
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FilteredDocIdSetIterator___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FilteredDocIdSetIterator___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FilteredDocIdSetIterator.__cast_(obj)

FilteredDocIdSetIterator_swigregister = _lucenepp.FilteredDocIdSetIterator_swigregister
FilteredDocIdSetIterator_swigregister(FilteredDocIdSetIterator)

def FilteredDocIdSetIterator___cast_(*args):
  return _lucenepp.FilteredDocIdSetIterator___cast_(*args)
FilteredDocIdSetIterator___cast_ = _lucenepp.FilteredDocIdSetIterator___cast_

class FilteredQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FilteredQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FilteredQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_FilteredQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_FilteredQuery
    __del__ = lambda self : None;
    def getQuery(self): return _lucenepp.FilteredQuery_getQuery(self)
    def getFilter(self): return _lucenepp.FilteredQuery_getFilter(self)
    def toString(self, *args): return _lucenepp.FilteredQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FilteredQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FilteredQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FilteredQuery.__cast_(obj)

FilteredQuery_swigregister = _lucenepp.FilteredQuery_swigregister
FilteredQuery_swigregister(FilteredQuery)

def FilteredQuery___cast_(*args):
  return _lucenepp.FilteredQuery___cast_(*args)
FilteredQuery___cast_ = _lucenepp.FilteredQuery___cast_

class FilteredTermEnum(TermEnum):
    __swig_setmethods__ = {}
    for _s in [TermEnum]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FilteredTermEnum, name, value)
    __swig_getmethods__ = {}
    for _s in [TermEnum]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FilteredTermEnum, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_FilteredTermEnum
    __del__ = lambda self : None;
    def difference(self): return _lucenepp.FilteredTermEnum_difference(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FilteredTermEnum___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FilteredTermEnum___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FilteredTermEnum.__cast_(obj)

FilteredTermEnum_swigregister = _lucenepp.FilteredTermEnum_swigregister
FilteredTermEnum_swigregister(FilteredTermEnum)

def FilteredTermEnum___cast_(*args):
  return _lucenepp.FilteredTermEnum___cast_(*args)
FilteredTermEnum___cast_ = _lucenepp.FilteredTermEnum___cast_

class FilterManager(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FilterManager, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FilterManager, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_FilterManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_FilterManager
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.FilterManager_getClassName(self)
    __swig_getmethods__["getInstance"] = lambda x: _lucenepp.FilterManager_getInstance
    if _newclass:getInstance = staticmethod(_lucenepp.FilterManager_getInstance)
    def setCacheSize(self, *args): return _lucenepp.FilterManager_setCacheSize(self, *args)
    def setCleanThreadSleepTime(self, *args): return _lucenepp.FilterManager_setCleanThreadSleepTime(self, *args)
    def getFilter(self, *args): return _lucenepp.FilterManager_getFilter(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FilterManager___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FilterManager___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FilterManager.__cast_(obj)

FilterManager_swigregister = _lucenepp.FilterManager_swigregister
FilterManager_swigregister(FilterManager)

def FilterManager_getInstance():
  return _lucenepp.FilterManager_getInstance()
FilterManager_getInstance = _lucenepp.FilterManager_getInstance

def FilterManager___cast_(*args):
  return _lucenepp.FilterManager___cast_(*args)
FilterManager___cast_ = _lucenepp.FilterManager___cast_

class CustomScoreQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CustomScoreQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CustomScoreQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_CustomScoreQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_CustomScoreQuery
    __del__ = lambda self : None;
    def toString(self, *args): return _lucenepp.CustomScoreQuery_toString(self, *args)
    def customScore(self, *args): return _lucenepp.CustomScoreQuery_customScore(self, *args)
    def customExplain(self, *args): return _lucenepp.CustomScoreQuery_customExplain(self, *args)
    def isStrict(self): return _lucenepp.CustomScoreQuery_isStrict(self)
    def setStrict(self, *args): return _lucenepp.CustomScoreQuery_setStrict(self, *args)
    def name(self): return _lucenepp.CustomScoreQuery_name(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.CustomScoreQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.CustomScoreQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return CustomScoreQuery.__cast_(obj)

CustomScoreQuery_swigregister = _lucenepp.CustomScoreQuery_swigregister
CustomScoreQuery_swigregister(CustomScoreQuery)

def CustomScoreQuery___cast_(*args):
  return _lucenepp.CustomScoreQuery___cast_(*args)
CustomScoreQuery___cast_ = _lucenepp.CustomScoreQuery___cast_

class ValueSourceQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ValueSourceQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ValueSourceQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_ValueSourceQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_ValueSourceQuery
    __del__ = lambda self : None;
    __swig_setmethods__["valSrc"] = _lucenepp.ValueSourceQuery_valSrc_set
    __swig_getmethods__["valSrc"] = _lucenepp.ValueSourceQuery_valSrc_get
    if _newclass:valSrc = _swig_property(_lucenepp.ValueSourceQuery_valSrc_get, _lucenepp.ValueSourceQuery_valSrc_set)
    def toString(self, *args): return _lucenepp.ValueSourceQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.ValueSourceQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.ValueSourceQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return ValueSourceQuery.__cast_(obj)

ValueSourceQuery_swigregister = _lucenepp.ValueSourceQuery_swigregister
ValueSourceQuery_swigregister(ValueSourceQuery)

def ValueSourceQuery___cast_(*args):
  return _lucenepp.ValueSourceQuery___cast_(*args)
ValueSourceQuery___cast_ = _lucenepp.ValueSourceQuery___cast_

class FieldScoreQuery(ValueSourceQuery):
    __swig_setmethods__ = {}
    for _s in [ValueSourceQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldScoreQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [ValueSourceQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FieldScoreQuery, name)
    __repr__ = _swig_repr
    BYTE = _lucenepp.FieldScoreQuery_BYTE
    INT = _lucenepp.FieldScoreQuery_INT
    DOUBLE = _lucenepp.FieldScoreQuery_DOUBLE
    def __init__(self, *args): 
        this = _lucenepp.new_FieldScoreQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_FieldScoreQuery
    __del__ = lambda self : None;
    __swig_getmethods__["getValueSource"] = lambda x: _lucenepp.FieldScoreQuery_getValueSource
    if _newclass:getValueSource = staticmethod(_lucenepp.FieldScoreQuery_getValueSource)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FieldScoreQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FieldScoreQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FieldScoreQuery.__cast_(obj)

FieldScoreQuery_swigregister = _lucenepp.FieldScoreQuery_swigregister
FieldScoreQuery_swigregister(FieldScoreQuery)

def FieldScoreQuery_getValueSource(*args):
  return _lucenepp.FieldScoreQuery_getValueSource(*args)
FieldScoreQuery_getValueSource = _lucenepp.FieldScoreQuery_getValueSource

def FieldScoreQuery___cast_(*args):
  return _lucenepp.FieldScoreQuery___cast_(*args)
FieldScoreQuery___cast_ = _lucenepp.FieldScoreQuery___cast_

class FuzzyQuery(MultiTermQuery):
    __swig_setmethods__ = {}
    for _s in [MultiTermQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FuzzyQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiTermQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FuzzyQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_FuzzyQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_FuzzyQuery
    __del__ = lambda self : None;
    __swig_getmethods__["defaultMinSimilarity"] = lambda x: _lucenepp.FuzzyQuery_defaultMinSimilarity
    if _newclass:defaultMinSimilarity = staticmethod(_lucenepp.FuzzyQuery_defaultMinSimilarity)
    def getMinSimilarity(self): return _lucenepp.FuzzyQuery_getMinSimilarity(self)
    def getPrefixLength(self): return _lucenepp.FuzzyQuery_getPrefixLength(self)
    def getTerm(self): return _lucenepp.FuzzyQuery_getTerm(self)
    def toString(self, *args): return _lucenepp.FuzzyQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FuzzyQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FuzzyQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FuzzyQuery.__cast_(obj)

FuzzyQuery_swigregister = _lucenepp.FuzzyQuery_swigregister
FuzzyQuery_swigregister(FuzzyQuery)

def FuzzyQuery_defaultMinSimilarity():
  return _lucenepp.FuzzyQuery_defaultMinSimilarity()
FuzzyQuery_defaultMinSimilarity = _lucenepp.FuzzyQuery_defaultMinSimilarity
FuzzyQuery.defaultPrefixLength = _lucenepp.cvar.FuzzyQuery_defaultPrefixLength

def FuzzyQuery___cast_(*args):
  return _lucenepp.FuzzyQuery___cast_(*args)
FuzzyQuery___cast_ = _lucenepp.FuzzyQuery___cast_

class FuzzyTermEnum(FilteredTermEnum):
    __swig_setmethods__ = {}
    for _s in [FilteredTermEnum]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FuzzyTermEnum, name, value)
    __swig_getmethods__ = {}
    for _s in [FilteredTermEnum]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FuzzyTermEnum, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_FuzzyTermEnum(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_FuzzyTermEnum
    __del__ = lambda self : None;
    def endEnum(self): return _lucenepp.FuzzyTermEnum_endEnum(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FuzzyTermEnum___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FuzzyTermEnum___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FuzzyTermEnum.__cast_(obj)

FuzzyTermEnum_swigregister = _lucenepp.FuzzyTermEnum_swigregister
FuzzyTermEnum_swigregister(FuzzyTermEnum)

def FuzzyTermEnum___cast_(*args):
  return _lucenepp.FuzzyTermEnum___cast_(*args)
FuzzyTermEnum___cast_ = _lucenepp.FuzzyTermEnum___cast_

class IndexSearcher(Searcher):
    __swig_setmethods__ = {}
    for _s in [Searcher]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndexSearcher, name, value)
    __swig_getmethods__ = {}
    for _s in [Searcher]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IndexSearcher, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_IndexSearcher(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_IndexSearcher
    __del__ = lambda self : None;
    __swig_setmethods__["reader"] = _lucenepp.IndexSearcher_reader_set
    __swig_getmethods__["reader"] = _lucenepp.IndexSearcher_reader_get
    if _newclass:reader = _swig_property(_lucenepp.IndexSearcher_reader_get, _lucenepp.IndexSearcher_reader_set)
    def getIndexReader(self): return _lucenepp.IndexSearcher_getIndexReader(self)
    def doc(self, *args): return _lucenepp.IndexSearcher_doc(self, *args)
    def search(self, *args): return _lucenepp.IndexSearcher_search(self, *args)
    def explain(self, *args): return _lucenepp.IndexSearcher_explain(self, *args)
    def setDefaultFieldSortScoring(self, *args): return _lucenepp.IndexSearcher_setDefaultFieldSortScoring(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.IndexSearcher___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.IndexSearcher___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return IndexSearcher.__cast_(obj)

IndexSearcher_swigregister = _lucenepp.IndexSearcher_swigregister
IndexSearcher_swigregister(IndexSearcher)

def IndexSearcher___cast_(*args):
  return _lucenepp.IndexSearcher___cast_(*args)
IndexSearcher___cast_ = _lucenepp.IndexSearcher___cast_

class MatchAllDocsQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MatchAllDocsQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MatchAllDocsQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_MatchAllDocsQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_MatchAllDocsQuery
    __del__ = lambda self : None;
    def toString(self, *args): return _lucenepp.MatchAllDocsQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.MatchAllDocsQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.MatchAllDocsQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return MatchAllDocsQuery.__cast_(obj)

MatchAllDocsQuery_swigregister = _lucenepp.MatchAllDocsQuery_swigregister
MatchAllDocsQuery_swigregister(MatchAllDocsQuery)

def MatchAllDocsQuery___cast_(*args):
  return _lucenepp.MatchAllDocsQuery___cast_(*args)
MatchAllDocsQuery___cast_ = _lucenepp.MatchAllDocsQuery___cast_

class MultiPhraseQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiPhraseQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiPhraseQuery, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_MultiPhraseQuery()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_MultiPhraseQuery
    __del__ = lambda self : None;
    def setSlop(self, *args): return _lucenepp.MultiPhraseQuery_setSlop(self, *args)
    def getSlop(self): return _lucenepp.MultiPhraseQuery_getSlop(self)
    def add(self, *args): return _lucenepp.MultiPhraseQuery_add(self, *args)
    def getTermArrays(self): return _lucenepp.MultiPhraseQuery_getTermArrays(self)
    def getPositions(self): return _lucenepp.MultiPhraseQuery_getPositions(self)
    def toString(self, *args): return _lucenepp.MultiPhraseQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.MultiPhraseQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.MultiPhraseQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return MultiPhraseQuery.__cast_(obj)

MultiPhraseQuery_swigregister = _lucenepp.MultiPhraseQuery_swigregister
MultiPhraseQuery_swigregister(MultiPhraseQuery)

def MultiPhraseQuery___cast_(*args):
  return _lucenepp.MultiPhraseQuery___cast_(*args)
MultiPhraseQuery___cast_ = _lucenepp.MultiPhraseQuery___cast_

class MultiSearcher(Searcher):
    __swig_setmethods__ = {}
    for _s in [Searcher]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiSearcher, name, value)
    __swig_getmethods__ = {}
    for _s in [Searcher]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiSearcher, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_MultiSearcher(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_MultiSearcher
    __del__ = lambda self : None;
    def getSearchables(self): return _lucenepp.MultiSearcher_getSearchables(self)
    def doc(self, *args): return _lucenepp.MultiSearcher_doc(self, *args)
    def subSearcher(self, *args): return _lucenepp.MultiSearcher_subSearcher(self, *args)
    def subDoc(self, *args): return _lucenepp.MultiSearcher_subDoc(self, *args)
    def search(self, *args): return _lucenepp.MultiSearcher_search(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.MultiSearcher___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.MultiSearcher___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return MultiSearcher.__cast_(obj)

MultiSearcher_swigregister = _lucenepp.MultiSearcher_swigregister
MultiSearcher_swigregister(MultiSearcher)

def MultiSearcher___cast_(*args):
  return _lucenepp.MultiSearcher___cast_(*args)
MultiSearcher___cast_ = _lucenepp.MultiSearcher___cast_

class MultiTermQueryWrapperFilter(Filter):
    __swig_setmethods__ = {}
    for _s in [Filter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiTermQueryWrapperFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [Filter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiTermQueryWrapperFilter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_MultiTermQueryWrapperFilter
    __del__ = lambda self : None;
    def getTotalNumberOfTerms(self): return _lucenepp.MultiTermQueryWrapperFilter_getTotalNumberOfTerms(self)
    def clearTotalNumberOfTerms(self): return _lucenepp.MultiTermQueryWrapperFilter_clearTotalNumberOfTerms(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.MultiTermQueryWrapperFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.MultiTermQueryWrapperFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return MultiTermQueryWrapperFilter.__cast_(obj)

MultiTermQueryWrapperFilter_swigregister = _lucenepp.MultiTermQueryWrapperFilter_swigregister
MultiTermQueryWrapperFilter_swigregister(MultiTermQueryWrapperFilter)

def MultiTermQueryWrapperFilter___cast_(*args):
  return _lucenepp.MultiTermQueryWrapperFilter___cast_(*args)
MultiTermQueryWrapperFilter___cast_ = _lucenepp.MultiTermQueryWrapperFilter___cast_

class NumericRangeFilter(MultiTermQueryWrapperFilter):
    __swig_setmethods__ = {}
    for _s in [MultiTermQueryWrapperFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericRangeFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiTermQueryWrapperFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericRangeFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_NumericRangeFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_NumericRangeFilter
    __del__ = lambda self : None;
    __swig_getmethods__["newLongRange"] = lambda x: _lucenepp.NumericRangeFilter_newLongRange
    if _newclass:newLongRange = staticmethod(_lucenepp.NumericRangeFilter_newLongRange)
    __swig_getmethods__["newIntRange"] = lambda x: _lucenepp.NumericRangeFilter_newIntRange
    if _newclass:newIntRange = staticmethod(_lucenepp.NumericRangeFilter_newIntRange)
    __swig_getmethods__["newDoubleRange"] = lambda x: _lucenepp.NumericRangeFilter_newDoubleRange
    if _newclass:newDoubleRange = staticmethod(_lucenepp.NumericRangeFilter_newDoubleRange)
    __swig_getmethods__["newNumericRange"] = lambda x: _lucenepp.NumericRangeFilter_newNumericRange
    if _newclass:newNumericRange = staticmethod(_lucenepp.NumericRangeFilter_newNumericRange)
    def getField(self): return _lucenepp.NumericRangeFilter_getField(self)
    def includesMin(self): return _lucenepp.NumericRangeFilter_includesMin(self)
    def includesMax(self): return _lucenepp.NumericRangeFilter_includesMax(self)
    def getMin(self): return _lucenepp.NumericRangeFilter_getMin(self)
    def getMax(self): return _lucenepp.NumericRangeFilter_getMax(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.NumericRangeFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.NumericRangeFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return NumericRangeFilter.__cast_(obj)

NumericRangeFilter_swigregister = _lucenepp.NumericRangeFilter_swigregister
NumericRangeFilter_swigregister(NumericRangeFilter)

def NumericRangeFilter_newLongRange(*args):
  return _lucenepp.NumericRangeFilter_newLongRange(*args)
NumericRangeFilter_newLongRange = _lucenepp.NumericRangeFilter_newLongRange

def NumericRangeFilter_newIntRange(*args):
  return _lucenepp.NumericRangeFilter_newIntRange(*args)
NumericRangeFilter_newIntRange = _lucenepp.NumericRangeFilter_newIntRange

def NumericRangeFilter_newDoubleRange(*args):
  return _lucenepp.NumericRangeFilter_newDoubleRange(*args)
NumericRangeFilter_newDoubleRange = _lucenepp.NumericRangeFilter_newDoubleRange

def NumericRangeFilter_newNumericRange(*args):
  return _lucenepp.NumericRangeFilter_newNumericRange(*args)
NumericRangeFilter_newNumericRange = _lucenepp.NumericRangeFilter_newNumericRange

def NumericRangeFilter___cast_(*args):
  return _lucenepp.NumericRangeFilter___cast_(*args)
NumericRangeFilter___cast_ = _lucenepp.NumericRangeFilter___cast_

class NumericRangeQuery(MultiTermQuery):
    __swig_setmethods__ = {}
    for _s in [MultiTermQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NumericRangeQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiTermQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NumericRangeQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_NumericRangeQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_NumericRangeQuery
    __del__ = lambda self : None;
    __swig_getmethods__["newLongRange"] = lambda x: _lucenepp.NumericRangeQuery_newLongRange
    if _newclass:newLongRange = staticmethod(_lucenepp.NumericRangeQuery_newLongRange)
    __swig_getmethods__["newIntRange"] = lambda x: _lucenepp.NumericRangeQuery_newIntRange
    if _newclass:newIntRange = staticmethod(_lucenepp.NumericRangeQuery_newIntRange)
    __swig_getmethods__["newDoubleRange"] = lambda x: _lucenepp.NumericRangeQuery_newDoubleRange
    if _newclass:newDoubleRange = staticmethod(_lucenepp.NumericRangeQuery_newDoubleRange)
    __swig_getmethods__["newNumericRange"] = lambda x: _lucenepp.NumericRangeQuery_newNumericRange
    if _newclass:newNumericRange = staticmethod(_lucenepp.NumericRangeQuery_newNumericRange)
    def getField(self): return _lucenepp.NumericRangeQuery_getField(self)
    def includesMin(self): return _lucenepp.NumericRangeQuery_includesMin(self)
    def includesMax(self): return _lucenepp.NumericRangeQuery_includesMax(self)
    def getMin(self): return _lucenepp.NumericRangeQuery_getMin(self)
    def getMax(self): return _lucenepp.NumericRangeQuery_getMax(self)
    def toString(self, *args): return _lucenepp.NumericRangeQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.NumericRangeQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.NumericRangeQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return NumericRangeQuery.__cast_(obj)

NumericRangeQuery_swigregister = _lucenepp.NumericRangeQuery_swigregister
NumericRangeQuery_swigregister(NumericRangeQuery)

def NumericRangeQuery_newLongRange(*args):
  return _lucenepp.NumericRangeQuery_newLongRange(*args)
NumericRangeQuery_newLongRange = _lucenepp.NumericRangeQuery_newLongRange

def NumericRangeQuery_newIntRange(*args):
  return _lucenepp.NumericRangeQuery_newIntRange(*args)
NumericRangeQuery_newIntRange = _lucenepp.NumericRangeQuery_newIntRange

def NumericRangeQuery_newDoubleRange(*args):
  return _lucenepp.NumericRangeQuery_newDoubleRange(*args)
NumericRangeQuery_newDoubleRange = _lucenepp.NumericRangeQuery_newDoubleRange

def NumericRangeQuery_newNumericRange(*args):
  return _lucenepp.NumericRangeQuery_newNumericRange(*args)
NumericRangeQuery_newNumericRange = _lucenepp.NumericRangeQuery_newNumericRange

def NumericRangeQuery___cast_(*args):
  return _lucenepp.NumericRangeQuery___cast_(*args)
NumericRangeQuery___cast_ = _lucenepp.NumericRangeQuery___cast_

class ParallelMultiSearcher(MultiSearcher):
    __swig_setmethods__ = {}
    for _s in [MultiSearcher]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParallelMultiSearcher, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiSearcher]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParallelMultiSearcher, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_ParallelMultiSearcher(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_ParallelMultiSearcher
    __del__ = lambda self : None;
    def search(self, *args): return _lucenepp.ParallelMultiSearcher_search(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.ParallelMultiSearcher___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.ParallelMultiSearcher___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return ParallelMultiSearcher.__cast_(obj)

ParallelMultiSearcher_swigregister = _lucenepp.ParallelMultiSearcher_swigregister
ParallelMultiSearcher_swigregister(ParallelMultiSearcher)

def ParallelMultiSearcher___cast_(*args):
  return _lucenepp.ParallelMultiSearcher___cast_(*args)
ParallelMultiSearcher___cast_ = _lucenepp.ParallelMultiSearcher___cast_

class PhraseQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PhraseQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PhraseQuery, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _lucenepp.new_PhraseQuery()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PhraseQuery
    __del__ = lambda self : None;
    def setSlop(self, *args): return _lucenepp.PhraseQuery_setSlop(self, *args)
    def getSlop(self): return _lucenepp.PhraseQuery_getSlop(self)
    def add(self, *args): return _lucenepp.PhraseQuery_add(self, *args)
    def getTerms(self): return _lucenepp.PhraseQuery_getTerms(self)
    def getPositions(self): return _lucenepp.PhraseQuery_getPositions(self)
    def toString(self, *args): return _lucenepp.PhraseQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PhraseQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PhraseQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PhraseQuery.__cast_(obj)

PhraseQuery_swigregister = _lucenepp.PhraseQuery_swigregister
PhraseQuery_swigregister(PhraseQuery)

def PhraseQuery___cast_(*args):
  return _lucenepp.PhraseQuery___cast_(*args)
PhraseQuery___cast_ = _lucenepp.PhraseQuery___cast_

class PrefixFilter(MultiTermQueryWrapperFilter):
    __swig_setmethods__ = {}
    for _s in [MultiTermQueryWrapperFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PrefixFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiTermQueryWrapperFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PrefixFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_PrefixFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PrefixFilter
    __del__ = lambda self : None;
    def getPrefix(self): return _lucenepp.PrefixFilter_getPrefix(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PrefixFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PrefixFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PrefixFilter.__cast_(obj)

PrefixFilter_swigregister = _lucenepp.PrefixFilter_swigregister
PrefixFilter_swigregister(PrefixFilter)

def PrefixFilter___cast_(*args):
  return _lucenepp.PrefixFilter___cast_(*args)
PrefixFilter___cast_ = _lucenepp.PrefixFilter___cast_

class PrefixQuery(MultiTermQuery):
    __swig_setmethods__ = {}
    for _s in [MultiTermQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PrefixQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiTermQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PrefixQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_PrefixQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PrefixQuery
    __del__ = lambda self : None;
    def getPrefix(self): return _lucenepp.PrefixQuery_getPrefix(self)
    def toString(self, *args): return _lucenepp.PrefixQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PrefixQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PrefixQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PrefixQuery.__cast_(obj)

PrefixQuery_swigregister = _lucenepp.PrefixQuery_swigregister
PrefixQuery_swigregister(PrefixQuery)

def PrefixQuery___cast_(*args):
  return _lucenepp.PrefixQuery___cast_(*args)
PrefixQuery___cast_ = _lucenepp.PrefixQuery___cast_

class PrefixTermEnum(FilteredTermEnum):
    __swig_setmethods__ = {}
    for _s in [FilteredTermEnum]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PrefixTermEnum, name, value)
    __swig_getmethods__ = {}
    for _s in [FilteredTermEnum]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PrefixTermEnum, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_PrefixTermEnum(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PrefixTermEnum
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PrefixTermEnum___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PrefixTermEnum___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PrefixTermEnum.__cast_(obj)

PrefixTermEnum_swigregister = _lucenepp.PrefixTermEnum_swigregister
PrefixTermEnum_swigregister(PrefixTermEnum)

def PrefixTermEnum___cast_(*args):
  return _lucenepp.PrefixTermEnum___cast_(*args)
PrefixTermEnum___cast_ = _lucenepp.PrefixTermEnum___cast_

class QueryTermVector(TermFreqVector,LuceneObject):
    __swig_setmethods__ = {}
    for _s in [TermFreqVector,LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QueryTermVector, name, value)
    __swig_getmethods__ = {}
    for _s in [TermFreqVector,LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QueryTermVector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_QueryTermVector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_QueryTermVector
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.QueryTermVector___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.QueryTermVector___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return QueryTermVector.__cast_(obj)

QueryTermVector_swigregister = _lucenepp.QueryTermVector_swigregister
QueryTermVector_swigregister(QueryTermVector)

def QueryTermVector___cast_(*args):
  return _lucenepp.QueryTermVector___cast_(*args)
QueryTermVector___cast_ = _lucenepp.QueryTermVector___cast_

class QueryWrapperFilter(Filter):
    __swig_setmethods__ = {}
    for _s in [Filter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QueryWrapperFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [Filter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QueryWrapperFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_QueryWrapperFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_QueryWrapperFilter
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.QueryWrapperFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.QueryWrapperFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return QueryWrapperFilter.__cast_(obj)

QueryWrapperFilter_swigregister = _lucenepp.QueryWrapperFilter_swigregister
QueryWrapperFilter_swigregister(QueryWrapperFilter)

def QueryWrapperFilter___cast_(*args):
  return _lucenepp.QueryWrapperFilter___cast_(*args)
QueryWrapperFilter___cast_ = _lucenepp.QueryWrapperFilter___cast_

class SingleTermEnum(FilteredTermEnum):
    __swig_setmethods__ = {}
    for _s in [FilteredTermEnum]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingleTermEnum, name, value)
    __swig_getmethods__ = {}
    for _s in [FilteredTermEnum]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingleTermEnum, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SingleTermEnum(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SingleTermEnum
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SingleTermEnum___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SingleTermEnum___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SingleTermEnum.__cast_(obj)

SingleTermEnum_swigregister = _lucenepp.SingleTermEnum_swigregister
SingleTermEnum_swigregister(SingleTermEnum)

def SingleTermEnum___cast_(*args):
  return _lucenepp.SingleTermEnum___cast_(*args)
SingleTermEnum___cast_ = _lucenepp.SingleTermEnum___cast_

class Sort(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Sort, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Sort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_Sort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_Sort
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Sort_getClassName(self)
    __swig_setmethods__["fields"] = _lucenepp.Sort_fields_set
    __swig_getmethods__["fields"] = _lucenepp.Sort_fields_get
    if _newclass:fields = _swig_property(_lucenepp.Sort_fields_get, _lucenepp.Sort_fields_set)
    __swig_getmethods__["RELEVANCE"] = lambda x: _lucenepp.Sort_RELEVANCE
    if _newclass:RELEVANCE = staticmethod(_lucenepp.Sort_RELEVANCE)
    __swig_getmethods__["INDEXORDER"] = lambda x: _lucenepp.Sort_INDEXORDER
    if _newclass:INDEXORDER = staticmethod(_lucenepp.Sort_INDEXORDER)
    def setSort(self, *args): return _lucenepp.Sort_setSort(self, *args)
    def getSort(self): return _lucenepp.Sort_getSort(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Sort___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Sort___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Sort.__cast_(obj)

Sort_swigregister = _lucenepp.Sort_swigregister
Sort_swigregister(Sort)

def Sort_RELEVANCE():
  return _lucenepp.Sort_RELEVANCE()
Sort_RELEVANCE = _lucenepp.Sort_RELEVANCE

def Sort_INDEXORDER():
  return _lucenepp.Sort_INDEXORDER()
Sort_INDEXORDER = _lucenepp.Sort_INDEXORDER

def Sort___cast_(*args):
  return _lucenepp.Sort___cast_(*args)
Sort___cast_ = _lucenepp.Sort___cast_

class SortField(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SortField, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SortField, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SortField(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SortField
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.SortField_getClassName(self)
    __swig_getmethods__["FIELD_SCORE"] = lambda x: _lucenepp.SortField_FIELD_SCORE
    if _newclass:FIELD_SCORE = staticmethod(_lucenepp.SortField_FIELD_SCORE)
    __swig_getmethods__["FIELD_DOC"] = lambda x: _lucenepp.SortField_FIELD_DOC
    if _newclass:FIELD_DOC = staticmethod(_lucenepp.SortField_FIELD_DOC)
    def getField(self): return _lucenepp.SortField_getField(self)
    def getType(self): return _lucenepp.SortField_getType(self)
    def getParser(self): return _lucenepp.SortField_getParser(self)
    def getReverse(self): return _lucenepp.SortField_getReverse(self)
    def getComparatorSource(self): return _lucenepp.SortField_getComparatorSource(self)
    def getComparator(self, *args): return _lucenepp.SortField_getComparator(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SortField___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SortField___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SortField.__cast_(obj)

SortField_swigregister = _lucenepp.SortField_swigregister
SortField_swigregister(SortField)
SortField.SCORE = _lucenepp.cvar.SortField_SCORE
SortField.DOC = _lucenepp.cvar.SortField_DOC
SortField.STRING = _lucenepp.cvar.SortField_STRING
SortField.INT = _lucenepp.cvar.SortField_INT
SortField.FLOAT = _lucenepp.cvar.SortField_FLOAT
SortField.LONG = _lucenepp.cvar.SortField_LONG
SortField.DOUBLE = _lucenepp.cvar.SortField_DOUBLE
SortField.SHORT = _lucenepp.cvar.SortField_SHORT
SortField.CUSTOM = _lucenepp.cvar.SortField_CUSTOM
SortField.BYTE = _lucenepp.cvar.SortField_BYTE
SortField.STRING_VAL = _lucenepp.cvar.SortField_STRING_VAL

def SortField_FIELD_SCORE():
  return _lucenepp.SortField_FIELD_SCORE()
SortField_FIELD_SCORE = _lucenepp.SortField_FIELD_SCORE

def SortField_FIELD_DOC():
  return _lucenepp.SortField_FIELD_DOC()
SortField_FIELD_DOC = _lucenepp.SortField_FIELD_DOC

def SortField___cast_(*args):
  return _lucenepp.SortField___cast_(*args)
SortField___cast_ = _lucenepp.SortField___cast_

class Spans(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Spans, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Spans, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_Spans
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.Spans_getClassName(self)
    def next(self): return _lucenepp.Spans_next(self)
    def skipTo(self, *args): return _lucenepp.Spans_skipTo(self, *args)
    def doc(self): return _lucenepp.Spans_doc(self)
    def start(self): return _lucenepp.Spans_start(self)
    def end(self): return _lucenepp.Spans_end(self)
    def getPayload(self): return _lucenepp.Spans_getPayload(self)
    def isPayloadAvailable(self): return _lucenepp.Spans_isPayloadAvailable(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.Spans___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.Spans___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return Spans.__cast_(obj)

Spans_swigregister = _lucenepp.Spans_swigregister
Spans_swigregister(Spans)

def Spans___cast_(*args):
  return _lucenepp.Spans___cast_(*args)
Spans___cast_ = _lucenepp.Spans___cast_

class PayloadSpanUtil(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadSpanUtil, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadSpanUtil, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_PayloadSpanUtil(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PayloadSpanUtil
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.PayloadSpanUtil_getClassName(self)
    def getPayloadsForQuery(self, *args): return _lucenepp.PayloadSpanUtil_getPayloadsForQuery(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PayloadSpanUtil___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PayloadSpanUtil___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PayloadSpanUtil.__cast_(obj)

PayloadSpanUtil_swigregister = _lucenepp.PayloadSpanUtil_swigregister
PayloadSpanUtil_swigregister(PayloadSpanUtil)

def PayloadSpanUtil___cast_(*args):
  return _lucenepp.PayloadSpanUtil___cast_(*args)
PayloadSpanUtil___cast_ = _lucenepp.PayloadSpanUtil___cast_

class SpanFilter(Filter):
    __swig_setmethods__ = {}
    for _s in [Filter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [Filter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpanFilter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SpanFilter
    __del__ = lambda self : None;
    def bitSpans(self, *args): return _lucenepp.SpanFilter_bitSpans(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanFilter.__cast_(obj)

SpanFilter_swigregister = _lucenepp.SpanFilter_swigregister
SpanFilter_swigregister(SpanFilter)

def SpanFilter___cast_(*args):
  return _lucenepp.SpanFilter___cast_(*args)
SpanFilter___cast_ = _lucenepp.SpanFilter___cast_

class SpanFilterResult(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanFilterResult, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpanFilterResult, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SpanFilterResult(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SpanFilterResult
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.SpanFilterResult_getClassName(self)
    def getPositions(self): return _lucenepp.SpanFilterResult_getPositions(self)
    def getDocIdSet(self): return _lucenepp.SpanFilterResult_getDocIdSet(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanFilterResult___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanFilterResult___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanFilterResult.__cast_(obj)

SpanFilterResult_swigregister = _lucenepp.SpanFilterResult_swigregister
SpanFilterResult_swigregister(SpanFilterResult)

def SpanFilterResult___cast_(*args):
  return _lucenepp.SpanFilterResult___cast_(*args)
SpanFilterResult___cast_ = _lucenepp.SpanFilterResult___cast_

class CachingSpanFilter(SpanFilter):
    __swig_setmethods__ = {}
    for _s in [SpanFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CachingSpanFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CachingSpanFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_CachingSpanFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_CachingSpanFilter
    __del__ = lambda self : None;
    __swig_setmethods__["hitCount"] = _lucenepp.CachingSpanFilter_hitCount_set
    __swig_getmethods__["hitCount"] = _lucenepp.CachingSpanFilter_hitCount_get
    if _newclass:hitCount = _swig_property(_lucenepp.CachingSpanFilter_hitCount_get, _lucenepp.CachingSpanFilter_hitCount_set)
    __swig_setmethods__["missCount"] = _lucenepp.CachingSpanFilter_missCount_set
    __swig_getmethods__["missCount"] = _lucenepp.CachingSpanFilter_missCount_get
    if _newclass:missCount = _swig_property(_lucenepp.CachingSpanFilter_missCount_get, _lucenepp.CachingSpanFilter_missCount_set)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.CachingSpanFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.CachingSpanFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return CachingSpanFilter.__cast_(obj)

CachingSpanFilter_swigregister = _lucenepp.CachingSpanFilter_swigregister
CachingSpanFilter_swigregister(CachingSpanFilter)

def CachingSpanFilter___cast_(*args):
  return _lucenepp.CachingSpanFilter___cast_(*args)
CachingSpanFilter___cast_ = _lucenepp.CachingSpanFilter___cast_

class SpanQueryFilter(SpanFilter):
    __swig_setmethods__ = {}
    for _s in [SpanFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanQueryFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpanQueryFilter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SpanQueryFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SpanQueryFilter
    __del__ = lambda self : None;
    def getQuery(self): return _lucenepp.SpanQueryFilter_getQuery(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanQueryFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanQueryFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanQueryFilter.__cast_(obj)

SpanQueryFilter_swigregister = _lucenepp.SpanQueryFilter_swigregister
SpanQueryFilter_swigregister(SpanQueryFilter)

def SpanQueryFilter___cast_(*args):
  return _lucenepp.SpanQueryFilter___cast_(*args)
SpanQueryFilter___cast_ = _lucenepp.SpanQueryFilter___cast_

class SpanQuery(Query):
    __swig_setmethods__ = {}
    for _s in [Query]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [Query]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpanQuery, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_SpanQuery
    __del__ = lambda self : None;
    def getSpans(self, *args): return _lucenepp.SpanQuery_getSpans(self, *args)
    def getField(self): return _lucenepp.SpanQuery_getField(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanQuery.__cast_(obj)

SpanQuery_swigregister = _lucenepp.SpanQuery_swigregister
SpanQuery_swigregister(SpanQuery)

def SpanQuery___cast_(*args):
  return _lucenepp.SpanQuery___cast_(*args)
SpanQuery___cast_ = _lucenepp.SpanQuery___cast_

class SpanFirstQuery(SpanQuery):
    __swig_setmethods__ = {}
    for _s in [SpanQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanFirstQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpanFirstQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SpanFirstQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SpanFirstQuery
    __del__ = lambda self : None;
    def getMatch(self): return _lucenepp.SpanFirstQuery_getMatch(self)
    def getEnd(self): return _lucenepp.SpanFirstQuery_getEnd(self)
    def toString(self, *args): return _lucenepp.SpanFirstQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanFirstQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanFirstQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanFirstQuery.__cast_(obj)

SpanFirstQuery_swigregister = _lucenepp.SpanFirstQuery_swigregister
SpanFirstQuery_swigregister(SpanFirstQuery)

def SpanFirstQuery___cast_(*args):
  return _lucenepp.SpanFirstQuery___cast_(*args)
SpanFirstQuery___cast_ = _lucenepp.SpanFirstQuery___cast_

class SpanNearQuery(SpanQuery):
    __swig_setmethods__ = {}
    for _s in [SpanQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanNearQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpanNearQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SpanNearQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SpanNearQuery
    __del__ = lambda self : None;
    def getClauses(self): return _lucenepp.SpanNearQuery_getClauses(self)
    def getSlop(self): return _lucenepp.SpanNearQuery_getSlop(self)
    def isInOrder(self): return _lucenepp.SpanNearQuery_isInOrder(self)
    def toString(self, *args): return _lucenepp.SpanNearQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanNearQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanNearQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanNearQuery.__cast_(obj)

SpanNearQuery_swigregister = _lucenepp.SpanNearQuery_swigregister
SpanNearQuery_swigregister(SpanNearQuery)

def SpanNearQuery___cast_(*args):
  return _lucenepp.SpanNearQuery___cast_(*args)
SpanNearQuery___cast_ = _lucenepp.SpanNearQuery___cast_

class SpanNotQuery(SpanQuery):
    __swig_setmethods__ = {}
    for _s in [SpanQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanNotQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpanNotQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SpanNotQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SpanNotQuery
    __del__ = lambda self : None;
    def getInclude(self): return _lucenepp.SpanNotQuery_getInclude(self)
    def getExclude(self): return _lucenepp.SpanNotQuery_getExclude(self)
    def toString(self, *args): return _lucenepp.SpanNotQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanNotQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanNotQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanNotQuery.__cast_(obj)

SpanNotQuery_swigregister = _lucenepp.SpanNotQuery_swigregister
SpanNotQuery_swigregister(SpanNotQuery)

def SpanNotQuery___cast_(*args):
  return _lucenepp.SpanNotQuery___cast_(*args)
SpanNotQuery___cast_ = _lucenepp.SpanNotQuery___cast_

class SpanOrQuery(SpanQuery):
    __swig_setmethods__ = {}
    for _s in [SpanQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanOrQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpanOrQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SpanOrQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SpanOrQuery
    __del__ = lambda self : None;
    def getClauses(self): return _lucenepp.SpanOrQuery_getClauses(self)
    def toString(self, *args): return _lucenepp.SpanOrQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanOrQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanOrQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanOrQuery.__cast_(obj)

SpanOrQuery_swigregister = _lucenepp.SpanOrQuery_swigregister
SpanOrQuery_swigregister(SpanOrQuery)

def SpanOrQuery___cast_(*args):
  return _lucenepp.SpanOrQuery___cast_(*args)
SpanOrQuery___cast_ = _lucenepp.SpanOrQuery___cast_

class SpanScorer(Scorer):
    __swig_setmethods__ = {}
    for _s in [Scorer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanScorer, name, value)
    __swig_getmethods__ = {}
    for _s in [Scorer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpanScorer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SpanScorer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SpanScorer
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanScorer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanScorer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanScorer.__cast_(obj)

SpanScorer_swigregister = _lucenepp.SpanScorer_swigregister
SpanScorer_swigregister(SpanScorer)

def SpanScorer___cast_(*args):
  return _lucenepp.SpanScorer___cast_(*args)
SpanScorer___cast_ = _lucenepp.SpanScorer___cast_

class SpanTermQuery(SpanQuery):
    __swig_setmethods__ = {}
    for _s in [SpanQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SpanTermQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SpanTermQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_SpanTermQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_SpanTermQuery
    __del__ = lambda self : None;
    def getTerm(self): return _lucenepp.SpanTermQuery_getTerm(self)
    def toString(self, *args): return _lucenepp.SpanTermQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.SpanTermQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.SpanTermQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return SpanTermQuery.__cast_(obj)

SpanTermQuery_swigregister = _lucenepp.SpanTermQuery_swigregister
SpanTermQuery_swigregister(SpanTermQuery)

def SpanTermQuery___cast_(*args):
  return _lucenepp.SpanTermQuery___cast_(*args)
SpanTermQuery___cast_ = _lucenepp.SpanTermQuery___cast_

class FieldMaskingSpanQuery(SpanQuery):
    __swig_setmethods__ = {}
    for _s in [SpanQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FieldMaskingSpanQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FieldMaskingSpanQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_FieldMaskingSpanQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_FieldMaskingSpanQuery
    __del__ = lambda self : None;
    def getMaskedQuery(self): return _lucenepp.FieldMaskingSpanQuery_getMaskedQuery(self)
    def toString(self, *args): return _lucenepp.FieldMaskingSpanQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.FieldMaskingSpanQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.FieldMaskingSpanQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return FieldMaskingSpanQuery.__cast_(obj)

FieldMaskingSpanQuery_swigregister = _lucenepp.FieldMaskingSpanQuery_swigregister
FieldMaskingSpanQuery_swigregister(FieldMaskingSpanQuery)

def FieldMaskingSpanQuery___cast_(*args):
  return _lucenepp.FieldMaskingSpanQuery___cast_(*args)
FieldMaskingSpanQuery___cast_ = _lucenepp.FieldMaskingSpanQuery___cast_

class NearSpansOrdered(Spans):
    __swig_setmethods__ = {}
    for _s in [Spans]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NearSpansOrdered, name, value)
    __swig_getmethods__ = {}
    for _s in [Spans]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearSpansOrdered, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_NearSpansOrdered(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_NearSpansOrdered
    __del__ = lambda self : None;
    def getSubSpans(self): return _lucenepp.NearSpansOrdered_getSubSpans(self)
    __swig_getmethods__["docSpansOrdered"] = lambda x: _lucenepp.NearSpansOrdered_docSpansOrdered
    if _newclass:docSpansOrdered = staticmethod(_lucenepp.NearSpansOrdered_docSpansOrdered)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.NearSpansOrdered___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.NearSpansOrdered___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return NearSpansOrdered.__cast_(obj)

NearSpansOrdered_swigregister = _lucenepp.NearSpansOrdered_swigregister
NearSpansOrdered_swigregister(NearSpansOrdered)

def NearSpansOrdered_docSpansOrdered(*args):
  return _lucenepp.NearSpansOrdered_docSpansOrdered(*args)
NearSpansOrdered_docSpansOrdered = _lucenepp.NearSpansOrdered_docSpansOrdered

def NearSpansOrdered___cast_(*args):
  return _lucenepp.NearSpansOrdered___cast_(*args)
NearSpansOrdered___cast_ = _lucenepp.NearSpansOrdered___cast_

class NearSpansUnordered(Spans):
    __swig_setmethods__ = {}
    for _s in [Spans]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NearSpansUnordered, name, value)
    __swig_getmethods__ = {}
    for _s in [Spans]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NearSpansUnordered, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_NearSpansUnordered(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_NearSpansUnordered
    __del__ = lambda self : None;
    def getSubSpans(self): return _lucenepp.NearSpansUnordered_getSubSpans(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.NearSpansUnordered___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.NearSpansUnordered___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return NearSpansUnordered.__cast_(obj)

NearSpansUnordered_swigregister = _lucenepp.NearSpansUnordered_swigregister
NearSpansUnordered_swigregister(NearSpansUnordered)

def NearSpansUnordered___cast_(*args):
  return _lucenepp.NearSpansUnordered___cast_(*args)
NearSpansUnordered___cast_ = _lucenepp.NearSpansUnordered___cast_

class PayloadNearQuery(SpanNearQuery):
    __swig_setmethods__ = {}
    for _s in [SpanNearQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadNearQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanNearQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadNearQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_PayloadNearQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PayloadNearQuery
    __del__ = lambda self : None;
    def toString(self, *args): return _lucenepp.PayloadNearQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PayloadNearQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PayloadNearQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PayloadNearQuery.__cast_(obj)

PayloadNearQuery_swigregister = _lucenepp.PayloadNearQuery_swigregister
PayloadNearQuery_swigregister(PayloadNearQuery)

def PayloadNearQuery___cast_(*args):
  return _lucenepp.PayloadNearQuery___cast_(*args)
PayloadNearQuery___cast_ = _lucenepp.PayloadNearQuery___cast_

class PayloadNearSpanWeight(SpanWeight):
    __swig_setmethods__ = {}
    for _s in [SpanWeight]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadNearSpanWeight, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanWeight]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadNearSpanWeight, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_PayloadNearSpanWeight(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PayloadNearSpanWeight
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PayloadNearSpanWeight___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PayloadNearSpanWeight___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PayloadNearSpanWeight.__cast_(obj)

PayloadNearSpanWeight_swigregister = _lucenepp.PayloadNearSpanWeight_swigregister
PayloadNearSpanWeight_swigregister(PayloadNearSpanWeight)

def PayloadNearSpanWeight___cast_(*args):
  return _lucenepp.PayloadNearSpanWeight___cast_(*args)
PayloadNearSpanWeight___cast_ = _lucenepp.PayloadNearSpanWeight___cast_

class PayloadNearSpanScorer(SpanScorer):
    __swig_setmethods__ = {}
    for _s in [SpanScorer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadNearSpanScorer, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanScorer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadNearSpanScorer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_PayloadNearSpanScorer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PayloadNearSpanScorer
    __del__ = lambda self : None;
    __swig_setmethods__["spans"] = _lucenepp.PayloadNearSpanScorer_spans_set
    __swig_getmethods__["spans"] = _lucenepp.PayloadNearSpanScorer_spans_get
    if _newclass:spans = _swig_property(_lucenepp.PayloadNearSpanScorer_spans_get, _lucenepp.PayloadNearSpanScorer_spans_set)
    __swig_setmethods__["similarity"] = _lucenepp.PayloadNearSpanScorer_similarity_set
    __swig_getmethods__["similarity"] = _lucenepp.PayloadNearSpanScorer_similarity_get
    if _newclass:similarity = _swig_property(_lucenepp.PayloadNearSpanScorer_similarity_get, _lucenepp.PayloadNearSpanScorer_similarity_set)
    def getPayloads(self, *args): return _lucenepp.PayloadNearSpanScorer_getPayloads(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PayloadNearSpanScorer___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PayloadNearSpanScorer___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PayloadNearSpanScorer.__cast_(obj)

PayloadNearSpanScorer_swigregister = _lucenepp.PayloadNearSpanScorer_swigregister
PayloadNearSpanScorer_swigregister(PayloadNearSpanScorer)

def PayloadNearSpanScorer___cast_(*args):
  return _lucenepp.PayloadNearSpanScorer___cast_(*args)
PayloadNearSpanScorer___cast_ = _lucenepp.PayloadNearSpanScorer___cast_

class PayloadTermQuery(SpanTermQuery):
    __swig_setmethods__ = {}
    for _s in [SpanTermQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadTermQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [SpanTermQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadTermQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_PayloadTermQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_PayloadTermQuery
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.PayloadTermQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.PayloadTermQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return PayloadTermQuery.__cast_(obj)

PayloadTermQuery_swigregister = _lucenepp.PayloadTermQuery_swigregister
PayloadTermQuery_swigregister(PayloadTermQuery)

def PayloadTermQuery___cast_(*args):
  return _lucenepp.PayloadTermQuery___cast_(*args)
PayloadTermQuery___cast_ = _lucenepp.PayloadTermQuery___cast_

class TermRangeFilter(MultiTermQueryWrapperFilter):
    __swig_setmethods__ = {}
    for _s in [MultiTermQueryWrapperFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermRangeFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiTermQueryWrapperFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TermRangeFilter, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TermRangeFilter
    __del__ = lambda self : None;
    __swig_getmethods__["Less"] = lambda x: _lucenepp.TermRangeFilter_Less
    if _newclass:Less = staticmethod(_lucenepp.TermRangeFilter_Less)
    __swig_getmethods__["More"] = lambda x: _lucenepp.TermRangeFilter_More
    if _newclass:More = staticmethod(_lucenepp.TermRangeFilter_More)
    def getField(self): return _lucenepp.TermRangeFilter_getField(self)
    def getLowerTerm(self): return _lucenepp.TermRangeFilter_getLowerTerm(self)
    def getUpperTerm(self): return _lucenepp.TermRangeFilter_getUpperTerm(self)
    def includesLower(self): return _lucenepp.TermRangeFilter_includesLower(self)
    def includesUpper(self): return _lucenepp.TermRangeFilter_includesUpper(self)
    def getCollator(self): return _lucenepp.TermRangeFilter_getCollator(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermRangeFilter___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermRangeFilter___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermRangeFilter.__cast_(obj)

    def __init__(self, *args): 
        this = _lucenepp.new_TermRangeFilter(*args)
        try: self.this.append(this)
        except: self.this = this
TermRangeFilter_swigregister = _lucenepp.TermRangeFilter_swigregister
TermRangeFilter_swigregister(TermRangeFilter)

def TermRangeFilter_Less(*args):
  return _lucenepp.TermRangeFilter_Less(*args)
TermRangeFilter_Less = _lucenepp.TermRangeFilter_Less

def TermRangeFilter_More(*args):
  return _lucenepp.TermRangeFilter_More(*args)
TermRangeFilter_More = _lucenepp.TermRangeFilter_More

def TermRangeFilter___cast_(*args):
  return _lucenepp.TermRangeFilter___cast_(*args)
TermRangeFilter___cast_ = _lucenepp.TermRangeFilter___cast_

class TermRangeQuery(MultiTermQuery):
    __swig_setmethods__ = {}
    for _s in [MultiTermQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermRangeQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiTermQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TermRangeQuery, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TermRangeQuery
    __del__ = lambda self : None;
    def getField(self): return _lucenepp.TermRangeQuery_getField(self)
    def getLowerTerm(self): return _lucenepp.TermRangeQuery_getLowerTerm(self)
    def getUpperTerm(self): return _lucenepp.TermRangeQuery_getUpperTerm(self)
    def includesLower(self): return _lucenepp.TermRangeQuery_includesLower(self)
    def includesUpper(self): return _lucenepp.TermRangeQuery_includesUpper(self)
    def getCollator(self): return _lucenepp.TermRangeQuery_getCollator(self)
    def toString(self, *args): return _lucenepp.TermRangeQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermRangeQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermRangeQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermRangeQuery.__cast_(obj)

    def __init__(self, *args): 
        this = _lucenepp.new_TermRangeQuery(*args)
        try: self.this.append(this)
        except: self.this = this
TermRangeQuery_swigregister = _lucenepp.TermRangeQuery_swigregister
TermRangeQuery_swigregister(TermRangeQuery)

def TermRangeQuery___cast_(*args):
  return _lucenepp.TermRangeQuery___cast_(*args)
TermRangeQuery___cast_ = _lucenepp.TermRangeQuery___cast_

class TermRangeTermEnum(FilteredTermEnum):
    __swig_setmethods__ = {}
    for _s in [FilteredTermEnum]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermRangeTermEnum, name, value)
    __swig_getmethods__ = {}
    for _s in [FilteredTermEnum]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TermRangeTermEnum, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_TermRangeTermEnum(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_TermRangeTermEnum
    __del__ = lambda self : None;
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermRangeTermEnum___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermRangeTermEnum___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermRangeTermEnum.__cast_(obj)

TermRangeTermEnum_swigregister = _lucenepp.TermRangeTermEnum_swigregister
TermRangeTermEnum_swigregister(TermRangeTermEnum)

def TermRangeTermEnum___cast_(*args):
  return _lucenepp.TermRangeTermEnum___cast_(*args)
TermRangeTermEnum___cast_ = _lucenepp.TermRangeTermEnum___cast_

class TermSpans(Spans):
    __swig_setmethods__ = {}
    for _s in [Spans]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TermSpans, name, value)
    __swig_getmethods__ = {}
    for _s in [Spans]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TermSpans, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_TermSpans(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_TermSpans
    __del__ = lambda self : None;
    def getPositions(self): return _lucenepp.TermSpans_getPositions(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TermSpans___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TermSpans___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TermSpans.__cast_(obj)

TermSpans_swigregister = _lucenepp.TermSpans_swigregister
TermSpans_swigregister(TermSpans)

def TermSpans___cast_(*args):
  return _lucenepp.TermSpans___cast_(*args)
TermSpans___cast_ = _lucenepp.TermSpans___cast_

class TimeLimitingCollector(Collector):
    __swig_setmethods__ = {}
    for _s in [Collector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeLimitingCollector, name, value)
    __swig_getmethods__ = {}
    for _s in [Collector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TimeLimitingCollector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_TimeLimitingCollector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_TimeLimitingCollector
    __del__ = lambda self : None;
    __swig_setmethods__["DEFAULT_GREEDY"] = _lucenepp.TimeLimitingCollector_DEFAULT_GREEDY_set
    __swig_getmethods__["DEFAULT_GREEDY"] = _lucenepp.TimeLimitingCollector_DEFAULT_GREEDY_get
    if _newclass:DEFAULT_GREEDY = _swig_property(_lucenepp.TimeLimitingCollector_DEFAULT_GREEDY_get, _lucenepp.TimeLimitingCollector_DEFAULT_GREEDY_set)
    __swig_getmethods__["getResolution"] = lambda x: _lucenepp.TimeLimitingCollector_getResolution
    if _newclass:getResolution = staticmethod(_lucenepp.TimeLimitingCollector_getResolution)
    __swig_getmethods__["setResolution"] = lambda x: _lucenepp.TimeLimitingCollector_setResolution
    if _newclass:setResolution = staticmethod(_lucenepp.TimeLimitingCollector_setResolution)
    __swig_getmethods__["stopTimer"] = lambda x: _lucenepp.TimeLimitingCollector_stopTimer
    if _newclass:stopTimer = staticmethod(_lucenepp.TimeLimitingCollector_stopTimer)
    def isGreedy(self): return _lucenepp.TimeLimitingCollector_isGreedy(self)
    def setGreedy(self, *args): return _lucenepp.TimeLimitingCollector_setGreedy(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TimeLimitingCollector___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TimeLimitingCollector___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TimeLimitingCollector.__cast_(obj)

TimeLimitingCollector_swigregister = _lucenepp.TimeLimitingCollector_swigregister
TimeLimitingCollector_swigregister(TimeLimitingCollector)
TimeLimitingCollector.DEFAULT_RESOLUTION = _lucenepp.cvar.TimeLimitingCollector_DEFAULT_RESOLUTION

def TimeLimitingCollector_getResolution():
  return _lucenepp.TimeLimitingCollector_getResolution()
TimeLimitingCollector_getResolution = _lucenepp.TimeLimitingCollector_getResolution

def TimeLimitingCollector_setResolution(*args):
  return _lucenepp.TimeLimitingCollector_setResolution(*args)
TimeLimitingCollector_setResolution = _lucenepp.TimeLimitingCollector_setResolution

def TimeLimitingCollector_stopTimer():
  return _lucenepp.TimeLimitingCollector_stopTimer()
TimeLimitingCollector_stopTimer = _lucenepp.TimeLimitingCollector_stopTimer

def TimeLimitingCollector___cast_(*args):
  return _lucenepp.TimeLimitingCollector___cast_(*args)
TimeLimitingCollector___cast_ = _lucenepp.TimeLimitingCollector___cast_

class TopDocs(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TopDocs, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TopDocs, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TopDocs
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.TopDocs_getClassName(self)
    __swig_setmethods__["totalHits"] = _lucenepp.TopDocs_totalHits_set
    __swig_getmethods__["totalHits"] = _lucenepp.TopDocs_totalHits_get
    if _newclass:totalHits = _swig_property(_lucenepp.TopDocs_totalHits_get, _lucenepp.TopDocs_totalHits_set)
    __swig_setmethods__["scoreDocs"] = _lucenepp.TopDocs_scoreDocs_set
    __swig_getmethods__["scoreDocs"] = _lucenepp.TopDocs_scoreDocs_get
    if _newclass:scoreDocs = _swig_property(_lucenepp.TopDocs_scoreDocs_get, _lucenepp.TopDocs_scoreDocs_set)
    __swig_setmethods__["maxScore"] = _lucenepp.TopDocs_maxScore_set
    __swig_getmethods__["maxScore"] = _lucenepp.TopDocs_maxScore_get
    if _newclass:maxScore = _swig_property(_lucenepp.TopDocs_maxScore_get, _lucenepp.TopDocs_maxScore_set)
    def getMaxScore(self): return _lucenepp.TopDocs_getMaxScore(self)
    def setMaxScore(self, *args): return _lucenepp.TopDocs_setMaxScore(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TopDocs___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TopDocs___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TopDocs.__cast_(obj)

TopDocs_swigregister = _lucenepp.TopDocs_swigregister
TopDocs_swigregister(TopDocs)

def TopDocs___cast_(*args):
  return _lucenepp.TopDocs___cast_(*args)
TopDocs___cast_ = _lucenepp.TopDocs___cast_

class TopDocsCollector(Collector):
    __swig_setmethods__ = {}
    for _s in [Collector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TopDocsCollector, name, value)
    __swig_getmethods__ = {}
    for _s in [Collector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TopDocsCollector, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TopDocsCollector
    __del__ = lambda self : None;
    def getTotalHits(self): return _lucenepp.TopDocsCollector_getTotalHits(self)
    def topDocs(self, *args): return _lucenepp.TopDocsCollector_topDocs(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TopDocsCollector___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TopDocsCollector___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TopDocsCollector.__cast_(obj)

TopDocsCollector_swigregister = _lucenepp.TopDocsCollector_swigregister
TopDocsCollector_swigregister(TopDocsCollector)

def TopDocsCollector___cast_(*args):
  return _lucenepp.TopDocsCollector___cast_(*args)
TopDocsCollector___cast_ = _lucenepp.TopDocsCollector___cast_

class TopFieldCollector(TopDocsCollector):
    __swig_setmethods__ = {}
    for _s in [TopDocsCollector]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TopFieldCollector, name, value)
    __swig_getmethods__ = {}
    for _s in [TopDocsCollector]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TopFieldCollector, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_TopFieldCollector
    __del__ = lambda self : None;
    __swig_getmethods__["create"] = lambda x: _lucenepp.TopFieldCollector_create
    if _newclass:create = staticmethod(_lucenepp.TopFieldCollector_create)
    def add(self, *args): return _lucenepp.TopFieldCollector_add(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TopFieldCollector___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TopFieldCollector___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TopFieldCollector.__cast_(obj)

TopFieldCollector_swigregister = _lucenepp.TopFieldCollector_swigregister
TopFieldCollector_swigregister(TopFieldCollector)

def TopFieldCollector_create(*args):
  return _lucenepp.TopFieldCollector_create(*args)
TopFieldCollector_create = _lucenepp.TopFieldCollector_create

def TopFieldCollector___cast_(*args):
  return _lucenepp.TopFieldCollector___cast_(*args)
TopFieldCollector___cast_ = _lucenepp.TopFieldCollector___cast_

class TopFieldDocs(TopDocs):
    __swig_setmethods__ = {}
    for _s in [TopDocs]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TopFieldDocs, name, value)
    __swig_getmethods__ = {}
    for _s in [TopDocs]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TopFieldDocs, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_TopFieldDocs(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_TopFieldDocs
    __del__ = lambda self : None;
    __swig_setmethods__["fields"] = _lucenepp.TopFieldDocs_fields_set
    __swig_getmethods__["fields"] = _lucenepp.TopFieldDocs_fields_get
    if _newclass:fields = _swig_property(_lucenepp.TopFieldDocs_fields_get, _lucenepp.TopFieldDocs_fields_set)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.TopFieldDocs___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.TopFieldDocs___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return TopFieldDocs.__cast_(obj)

TopFieldDocs_swigregister = _lucenepp.TopFieldDocs_swigregister
TopFieldDocs_swigregister(TopFieldDocs)

def TopFieldDocs___cast_(*args):
  return _lucenepp.TopFieldDocs___cast_(*args)
TopFieldDocs___cast_ = _lucenepp.TopFieldDocs___cast_

class WildcardQuery(MultiTermQuery):
    __swig_setmethods__ = {}
    for _s in [MultiTermQuery]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WildcardQuery, name, value)
    __swig_getmethods__ = {}
    for _s in [MultiTermQuery]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WildcardQuery, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_WildcardQuery(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_WildcardQuery
    __del__ = lambda self : None;
    def getTerm(self): return _lucenepp.WildcardQuery_getTerm(self)
    def toString(self, *args): return _lucenepp.WildcardQuery_toString(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.WildcardQuery___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.WildcardQuery___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return WildcardQuery.__cast_(obj)

WildcardQuery_swigregister = _lucenepp.WildcardQuery_swigregister
WildcardQuery_swigregister(WildcardQuery)

def WildcardQuery___cast_(*args):
  return _lucenepp.WildcardQuery___cast_(*args)
WildcardQuery___cast_ = _lucenepp.WildcardQuery___cast_

class WildcardTermEnum(FilteredTermEnum):
    __swig_setmethods__ = {}
    for _s in [FilteredTermEnum]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WildcardTermEnum, name, value)
    __swig_getmethods__ = {}
    for _s in [FilteredTermEnum]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WildcardTermEnum, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_WildcardTermEnum(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_WildcardTermEnum
    __del__ = lambda self : None;
    __swig_setmethods__["searchTerm"] = _lucenepp.WildcardTermEnum_searchTerm_set
    __swig_getmethods__["searchTerm"] = _lucenepp.WildcardTermEnum_searchTerm_get
    if _newclass:searchTerm = _swig_property(_lucenepp.WildcardTermEnum_searchTerm_get, _lucenepp.WildcardTermEnum_searchTerm_set)
    __swig_setmethods__["field"] = _lucenepp.WildcardTermEnum_field_set
    __swig_getmethods__["field"] = _lucenepp.WildcardTermEnum_field_get
    if _newclass:field = _swig_property(_lucenepp.WildcardTermEnum_field_get, _lucenepp.WildcardTermEnum_field_set)
    __swig_setmethods__["text"] = _lucenepp.WildcardTermEnum_text_set
    __swig_getmethods__["text"] = _lucenepp.WildcardTermEnum_text_get
    if _newclass:text = _swig_property(_lucenepp.WildcardTermEnum_text_get, _lucenepp.WildcardTermEnum_text_set)
    __swig_setmethods__["pre"] = _lucenepp.WildcardTermEnum_pre_set
    __swig_getmethods__["pre"] = _lucenepp.WildcardTermEnum_pre_get
    if _newclass:pre = _swig_property(_lucenepp.WildcardTermEnum_pre_get, _lucenepp.WildcardTermEnum_pre_set)
    __swig_setmethods__["preLen"] = _lucenepp.WildcardTermEnum_preLen_set
    __swig_getmethods__["preLen"] = _lucenepp.WildcardTermEnum_preLen_get
    if _newclass:preLen = _swig_property(_lucenepp.WildcardTermEnum_preLen_get, _lucenepp.WildcardTermEnum_preLen_set)
    __swig_setmethods__["_endEnum"] = _lucenepp.WildcardTermEnum__endEnum_set
    __swig_getmethods__["_endEnum"] = _lucenepp.WildcardTermEnum__endEnum_get
    if _newclass:_endEnum = _swig_property(_lucenepp.WildcardTermEnum__endEnum_get, _lucenepp.WildcardTermEnum__endEnum_set)
    __swig_getmethods__["wildcardEquals"] = lambda x: _lucenepp.WildcardTermEnum_wildcardEquals
    if _newclass:wildcardEquals = staticmethod(_lucenepp.WildcardTermEnum_wildcardEquals)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.WildcardTermEnum___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.WildcardTermEnum___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return WildcardTermEnum.__cast_(obj)

WildcardTermEnum_swigregister = _lucenepp.WildcardTermEnum_swigregister
WildcardTermEnum_swigregister(WildcardTermEnum)
WildcardTermEnum.WILDCARD_STRING = _lucenepp.cvar.WildcardTermEnum_WILDCARD_STRING
WildcardTermEnum.WILDCARD_CHAR = _lucenepp.cvar.WildcardTermEnum_WILDCARD_CHAR

def WildcardTermEnum_wildcardEquals(*args):
  return _lucenepp.WildcardTermEnum_wildcardEquals(*args)
WildcardTermEnum_wildcardEquals = _lucenepp.WildcardTermEnum_wildcardEquals

def WildcardTermEnum___cast_(*args):
  return _lucenepp.WildcardTermEnum___cast_(*args)
WildcardTermEnum___cast_ = _lucenepp.WildcardTermEnum___cast_

class QueryParserCharStream(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QueryParserCharStream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QueryParserCharStream, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getClassName(self): return _lucenepp.QueryParserCharStream_getClassName(self)
    def readChar(self): return _lucenepp.QueryParserCharStream_readChar(self)
    def getColumn(self): return _lucenepp.QueryParserCharStream_getColumn(self)
    def getLine(self): return _lucenepp.QueryParserCharStream_getLine(self)
    def getEndColumn(self): return _lucenepp.QueryParserCharStream_getEndColumn(self)
    def getEndLine(self): return _lucenepp.QueryParserCharStream_getEndLine(self)
    def getBeginColumn(self): return _lucenepp.QueryParserCharStream_getBeginColumn(self)
    def getBeginLine(self): return _lucenepp.QueryParserCharStream_getBeginLine(self)
    def backup(self, *args): return _lucenepp.QueryParserCharStream_backup(self, *args)
    def BeginToken(self): return _lucenepp.QueryParserCharStream_BeginToken(self)
    def GetImage(self): return _lucenepp.QueryParserCharStream_GetImage(self)
    def GetSuffix(self, *args): return _lucenepp.QueryParserCharStream_GetSuffix(self, *args)
    def Done(self): return _lucenepp.QueryParserCharStream_Done(self)
    def toLuceneObject__(self, *args): return _lucenepp.QueryParserCharStream_toLuceneObject__(self, *args)
    def toLuceneObject(self): return self.toLuceneObject__(self)

    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.QueryParserCharStream___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.QueryParserCharStream___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return QueryParserCharStream.__cast_(obj)

    __swig_destroy__ = _lucenepp.delete_QueryParserCharStream
    __del__ = lambda self : None;
QueryParserCharStream_swigregister = _lucenepp.QueryParserCharStream_swigregister
QueryParserCharStream_swigregister(QueryParserCharStream)

def QueryParserCharStream___cast_(*args):
  return _lucenepp.QueryParserCharStream___cast_(*args)
QueryParserCharStream___cast_ = _lucenepp.QueryParserCharStream___cast_

class QueryParserConstants(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QueryParserConstants, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QueryParserConstants, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _lucenepp.delete_QueryParserConstants
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.QueryParserConstants_getClassName(self)
    _EOF = _lucenepp.QueryParserConstants__EOF
    _NUM_CHAR = _lucenepp.QueryParserConstants__NUM_CHAR
    _ESCAPED_CHAR = _lucenepp.QueryParserConstants__ESCAPED_CHAR
    _TERM_START_CHAR = _lucenepp.QueryParserConstants__TERM_START_CHAR
    _TERM_CHAR = _lucenepp.QueryParserConstants__TERM_CHAR
    _WHITESPACE = _lucenepp.QueryParserConstants__WHITESPACE
    _QUOTED_CHAR = _lucenepp.QueryParserConstants__QUOTED_CHAR
    AND = _lucenepp.QueryParserConstants_AND
    OR = _lucenepp.QueryParserConstants_OR
    NOT = _lucenepp.QueryParserConstants_NOT
    PLUS = _lucenepp.QueryParserConstants_PLUS
    MINUS = _lucenepp.QueryParserConstants_MINUS
    LPAREN = _lucenepp.QueryParserConstants_LPAREN
    RPAREN = _lucenepp.QueryParserConstants_RPAREN
    COLON = _lucenepp.QueryParserConstants_COLON
    STAR = _lucenepp.QueryParserConstants_STAR
    CARAT = _lucenepp.QueryParserConstants_CARAT
    QUOTED = _lucenepp.QueryParserConstants_QUOTED
    TERM = _lucenepp.QueryParserConstants_TERM
    FUZZY_SLOP = _lucenepp.QueryParserConstants_FUZZY_SLOP
    PREFIXTERM = _lucenepp.QueryParserConstants_PREFIXTERM
    WILDTERM = _lucenepp.QueryParserConstants_WILDTERM
    RANGEIN_START = _lucenepp.QueryParserConstants_RANGEIN_START
    RANGEEX_START = _lucenepp.QueryParserConstants_RANGEEX_START
    NUMBER = _lucenepp.QueryParserConstants_NUMBER
    RANGEIN_TO = _lucenepp.QueryParserConstants_RANGEIN_TO
    RANGEIN_END = _lucenepp.QueryParserConstants_RANGEIN_END
    RANGEIN_QUOTED = _lucenepp.QueryParserConstants_RANGEIN_QUOTED
    RANGEIN_GOOP = _lucenepp.QueryParserConstants_RANGEIN_GOOP
    RANGEEX_TO = _lucenepp.QueryParserConstants_RANGEEX_TO
    RANGEEX_END = _lucenepp.QueryParserConstants_RANGEEX_END
    RANGEEX_QUOTED = _lucenepp.QueryParserConstants_RANGEEX_QUOTED
    RANGEEX_GOOP = _lucenepp.QueryParserConstants_RANGEEX_GOOP
    Boost = _lucenepp.QueryParserConstants_Boost
    RangeEx = _lucenepp.QueryParserConstants_RangeEx
    RangeIn = _lucenepp.QueryParserConstants_RangeIn
    DEFAULT = _lucenepp.QueryParserConstants_DEFAULT
    __swig_setmethods__["tokenImage"] = _lucenepp.QueryParserConstants_tokenImage_set
    __swig_getmethods__["tokenImage"] = _lucenepp.QueryParserConstants_tokenImage_get
    if _newclass:tokenImage = _swig_property(_lucenepp.QueryParserConstants_tokenImage_get, _lucenepp.QueryParserConstants_tokenImage_set)
QueryParserConstants_swigregister = _lucenepp.QueryParserConstants_swigregister
QueryParserConstants_swigregister(QueryParserConstants)

class QueryParser(QueryParserConstants,LuceneObject):
    __swig_setmethods__ = {}
    for _s in [QueryParserConstants,LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QueryParser, name, value)
    __swig_getmethods__ = {}
    for _s in [QueryParserConstants,LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QueryParser, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        if self.__class__ == QueryParser:
            _self = None
        else:
            _self = self
        this = _lucenepp.new_QueryParser(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_QueryParser
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.QueryParser_getClassName(self)
    OR_OPERATOR = _lucenepp.QueryParser_OR_OPERATOR
    AND_OPERATOR = _lucenepp.QueryParser_AND_OPERATOR
    __swig_setmethods__["token_source"] = _lucenepp.QueryParser_token_source_set
    __swig_getmethods__["token_source"] = _lucenepp.QueryParser_token_source_get
    if _newclass:token_source = _swig_property(_lucenepp.QueryParser_token_source_get, _lucenepp.QueryParser_token_source_set)
    __swig_setmethods__["token"] = _lucenepp.QueryParser_token_set
    __swig_getmethods__["token"] = _lucenepp.QueryParser_token_get
    if _newclass:token = _swig_property(_lucenepp.QueryParser_token_get, _lucenepp.QueryParser_token_set)
    __swig_setmethods__["jj_nt"] = _lucenepp.QueryParser_jj_nt_set
    __swig_getmethods__["jj_nt"] = _lucenepp.QueryParser_jj_nt_get
    if _newclass:jj_nt = _swig_property(_lucenepp.QueryParser_jj_nt_get, _lucenepp.QueryParser_jj_nt_set)
    def parse(self, *args): return _lucenepp.QueryParser_parse(self, *args)
    def getAnalyzer(self): return _lucenepp.QueryParser_getAnalyzer(self)
    def getField(self): return _lucenepp.QueryParser_getField(self)
    def getFuzzyMinSim(self): return _lucenepp.QueryParser_getFuzzyMinSim(self)
    def setFuzzyMinSim(self, *args): return _lucenepp.QueryParser_setFuzzyMinSim(self, *args)
    def getFuzzyPrefixLength(self): return _lucenepp.QueryParser_getFuzzyPrefixLength(self)
    def setFuzzyPrefixLength(self, *args): return _lucenepp.QueryParser_setFuzzyPrefixLength(self, *args)
    def setPhraseSlop(self, *args): return _lucenepp.QueryParser_setPhraseSlop(self, *args)
    def getPhraseSlop(self): return _lucenepp.QueryParser_getPhraseSlop(self)
    def setAllowLeadingWildcard(self, *args): return _lucenepp.QueryParser_setAllowLeadingWildcard(self, *args)
    def getAllowLeadingWildcard(self): return _lucenepp.QueryParser_getAllowLeadingWildcard(self)
    def setEnablePositionIncrements(self, *args): return _lucenepp.QueryParser_setEnablePositionIncrements(self, *args)
    def getEnablePositionIncrements(self): return _lucenepp.QueryParser_getEnablePositionIncrements(self)
    def setDefaultOperator(self, *args): return _lucenepp.QueryParser_setDefaultOperator(self, *args)
    def getDefaultOperator(self): return _lucenepp.QueryParser_getDefaultOperator(self)
    def setLowercaseExpandedTerms(self, *args): return _lucenepp.QueryParser_setLowercaseExpandedTerms(self, *args)
    def getLowercaseExpandedTerms(self): return _lucenepp.QueryParser_getLowercaseExpandedTerms(self)
    def setMultiTermRewriteMethod(self, *args): return _lucenepp.QueryParser_setMultiTermRewriteMethod(self, *args)
    def getMultiTermRewriteMethod(self): return _lucenepp.QueryParser_getMultiTermRewriteMethod(self)
    def setLocale(self, *args): return _lucenepp.QueryParser_setLocale(self, *args)
    def getLocale(self): return _lucenepp.QueryParser_getLocale(self)
    def setDateResolution(self, *args): return _lucenepp.QueryParser_setDateResolution(self, *args)
    def getDateResolution(self, *args): return _lucenepp.QueryParser_getDateResolution(self, *args)
    def setRangeCollator(self, *args): return _lucenepp.QueryParser_setRangeCollator(self, *args)
    def getRangeCollator(self): return _lucenepp.QueryParser_getRangeCollator(self)
    __swig_getmethods__["main"] = lambda x: _lucenepp.QueryParser_main
    if _newclass:main = staticmethod(_lucenepp.QueryParser_main)
    def Conjunction(self): return _lucenepp.QueryParser_Conjunction(self)
    def Modifiers(self): return _lucenepp.QueryParser_Modifiers(self)
    def TopLevelQuery(self, *args): return _lucenepp.QueryParser_TopLevelQuery(self, *args)
    def ParseQuery(self, *args): return _lucenepp.QueryParser_ParseQuery(self, *args)
    def ParseClause(self, *args): return _lucenepp.QueryParser_ParseClause(self, *args)
    def ParseTerm(self, *args): return _lucenepp.QueryParser_ParseTerm(self, *args)
    def ReInit(self, *args): return _lucenepp.QueryParser_ReInit(self, *args)
    def getNextToken(self): return _lucenepp.QueryParser_getNextToken(self)
    def getToken(self, *args): return _lucenepp.QueryParser_getToken(self, *args)
    def generateParseException(self): return _lucenepp.QueryParser_generateParseException(self)
    def enable_tracing(self): return _lucenepp.QueryParser_enable_tracing(self)
    def disable_tracing(self): return _lucenepp.QueryParser_disable_tracing(self)
    def addClause(self, *args): return _lucenepp.QueryParser_addClause(self, *args)
    def getFieldQuery(self, *args): return _lucenepp.QueryParser_getFieldQuery(self, *args)
    def getRangeQuery(self, *args): return _lucenepp.QueryParser_getRangeQuery(self, *args)
    def getBooleanQuery(self, *args): return _lucenepp.QueryParser_getBooleanQuery(self, *args)
    def getWildcardQuery(self, *args): return _lucenepp.QueryParser_getWildcardQuery(self, *args)
    def getPrefixQuery(self, *args): return _lucenepp.QueryParser_getPrefixQuery(self, *args)
    def getFuzzyQuery(self, *args): return _lucenepp.QueryParser_getFuzzyQuery(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.QueryParser___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.QueryParser___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return QueryParser.__cast_(obj)

    def __disown__(self):
        self.this.disown()
        _lucenepp.disown_QueryParser(self)
        return weakref_proxy(self)
QueryParser_swigregister = _lucenepp.QueryParser_swigregister
QueryParser_swigregister(QueryParser)

def QueryParser_main(*args):
  return _lucenepp.QueryParser_main(*args)
QueryParser_main = _lucenepp.QueryParser_main

def QueryParser___cast_(*args):
  return _lucenepp.QueryParser___cast_(*args)
QueryParser___cast_ = _lucenepp.QueryParser___cast_

class QueryParserToken(LuceneObject):
    __swig_setmethods__ = {}
    for _s in [LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QueryParserToken, name, value)
    __swig_getmethods__ = {}
    for _s in [LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QueryParserToken, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_QueryParserToken(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_QueryParserToken
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.QueryParserToken_getClassName(self)
    __swig_setmethods__["kind"] = _lucenepp.QueryParserToken_kind_set
    __swig_getmethods__["kind"] = _lucenepp.QueryParserToken_kind_get
    if _newclass:kind = _swig_property(_lucenepp.QueryParserToken_kind_get, _lucenepp.QueryParserToken_kind_set)
    __swig_setmethods__["beginLine"] = _lucenepp.QueryParserToken_beginLine_set
    __swig_getmethods__["beginLine"] = _lucenepp.QueryParserToken_beginLine_get
    if _newclass:beginLine = _swig_property(_lucenepp.QueryParserToken_beginLine_get, _lucenepp.QueryParserToken_beginLine_set)
    __swig_setmethods__["beginColumn"] = _lucenepp.QueryParserToken_beginColumn_set
    __swig_getmethods__["beginColumn"] = _lucenepp.QueryParserToken_beginColumn_get
    if _newclass:beginColumn = _swig_property(_lucenepp.QueryParserToken_beginColumn_get, _lucenepp.QueryParserToken_beginColumn_set)
    __swig_setmethods__["endLine"] = _lucenepp.QueryParserToken_endLine_set
    __swig_getmethods__["endLine"] = _lucenepp.QueryParserToken_endLine_get
    if _newclass:endLine = _swig_property(_lucenepp.QueryParserToken_endLine_get, _lucenepp.QueryParserToken_endLine_set)
    __swig_setmethods__["endColumn"] = _lucenepp.QueryParserToken_endColumn_set
    __swig_getmethods__["endColumn"] = _lucenepp.QueryParserToken_endColumn_get
    if _newclass:endColumn = _swig_property(_lucenepp.QueryParserToken_endColumn_get, _lucenepp.QueryParserToken_endColumn_set)
    __swig_setmethods__["image"] = _lucenepp.QueryParserToken_image_set
    __swig_getmethods__["image"] = _lucenepp.QueryParserToken_image_get
    if _newclass:image = _swig_property(_lucenepp.QueryParserToken_image_get, _lucenepp.QueryParserToken_image_set)
    __swig_setmethods__["next"] = _lucenepp.QueryParserToken_next_set
    __swig_getmethods__["next"] = _lucenepp.QueryParserToken_next_get
    if _newclass:next = _swig_property(_lucenepp.QueryParserToken_next_get, _lucenepp.QueryParserToken_next_set)
    __swig_setmethods__["specialToken"] = _lucenepp.QueryParserToken_specialToken_set
    __swig_getmethods__["specialToken"] = _lucenepp.QueryParserToken_specialToken_get
    if _newclass:specialToken = _swig_property(_lucenepp.QueryParserToken_specialToken_get, _lucenepp.QueryParserToken_specialToken_set)
    __swig_getmethods__["newToken"] = lambda x: _lucenepp.QueryParserToken_newToken
    if _newclass:newToken = staticmethod(_lucenepp.QueryParserToken_newToken)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.QueryParserToken___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.QueryParserToken___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return QueryParserToken.__cast_(obj)

QueryParserToken_swigregister = _lucenepp.QueryParserToken_swigregister
QueryParserToken_swigregister(QueryParserToken)

def QueryParserToken_newToken(*args):
  return _lucenepp.QueryParserToken_newToken(*args)
QueryParserToken_newToken = _lucenepp.QueryParserToken_newToken

def QueryParserToken___cast_(*args):
  return _lucenepp.QueryParserToken___cast_(*args)
QueryParserToken___cast_ = _lucenepp.QueryParserToken___cast_

class QueryParserTokenManager(QueryParserConstants,LuceneObject):
    __swig_setmethods__ = {}
    for _s in [QueryParserConstants,LuceneObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QueryParserTokenManager, name, value)
    __swig_getmethods__ = {}
    for _s in [QueryParserConstants,LuceneObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QueryParserTokenManager, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _lucenepp.new_QueryParserTokenManager(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_QueryParserTokenManager
    __del__ = lambda self : None;
    def setDebugStream(self, *args): return _lucenepp.QueryParserTokenManager_setDebugStream(self, *args)
    def ReInit(self, *args): return _lucenepp.QueryParserTokenManager_ReInit(self, *args)
    def SwitchTo(self, *args): return _lucenepp.QueryParserTokenManager_SwitchTo(self, *args)
    def getNextToken(self): return _lucenepp.QueryParserTokenManager_getNextToken(self)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.QueryParserTokenManager___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.QueryParserTokenManager___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return QueryParserTokenManager.__cast_(obj)

QueryParserTokenManager_swigregister = _lucenepp.QueryParserTokenManager_swigregister
QueryParserTokenManager_swigregister(QueryParserTokenManager)

def QueryParserTokenManager___cast_(*args):
  return _lucenepp.QueryParserTokenManager___cast_(*args)
QueryParserTokenManager___cast_ = _lucenepp.QueryParserTokenManager___cast_

class MultiFieldQueryParser(QueryParser):
    __swig_setmethods__ = {}
    for _s in [QueryParser]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiFieldQueryParser, name, value)
    __swig_getmethods__ = {}
    for _s in [QueryParser]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiFieldQueryParser, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        if self.__class__ == MultiFieldQueryParser:
            _self = None
        else:
            _self = self
        this = _lucenepp.new_MultiFieldQueryParser(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _lucenepp.delete_MultiFieldQueryParser
    __del__ = lambda self : None;
    def getClassName(self): return _lucenepp.MultiFieldQueryParser_getClassName(self)
    __swig_getmethods__["parse"] = lambda x: _lucenepp.MultiFieldQueryParser_parse
    if _newclass:parse = staticmethod(_lucenepp.MultiFieldQueryParser_parse)
    def getFieldQuery(self, *args): return _lucenepp.MultiFieldQueryParser_getFieldQuery(self, *args)
    def getFuzzyQuery(self, *args): return _lucenepp.MultiFieldQueryParser_getFuzzyQuery(self, *args)
    def getPrefixQuery(self, *args): return _lucenepp.MultiFieldQueryParser_getPrefixQuery(self, *args)
    def getWildcardQuery(self, *args): return _lucenepp.MultiFieldQueryParser_getWildcardQuery(self, *args)
    def getRangeQuery(self, *args): return _lucenepp.MultiFieldQueryParser_getRangeQuery(self, *args)
    __swig_getmethods__["__cast_"] = lambda x: _lucenepp.MultiFieldQueryParser___cast_
    if _newclass:__cast_ = staticmethod(_lucenepp.MultiFieldQueryParser___cast_)
    @staticmethod
    def cast_(obj):
      if getattr(obj, "toLuceneObject", None): obj = obj.toLuceneObject()
      return MultiFieldQueryParser.__cast_(obj)

    def __disown__(self):
        self.this.disown()
        _lucenepp.disown_MultiFieldQueryParser(self)
        return weakref_proxy(self)
    def addClause(self, *args): return _lucenepp.MultiFieldQueryParser_addClause(self, *args)
    def getBooleanQuery(self, *args): return _lucenepp.MultiFieldQueryParser_getBooleanQuery(self, *args)
MultiFieldQueryParser_swigregister = _lucenepp.MultiFieldQueryParser_swigregister
MultiFieldQueryParser_swigregister(MultiFieldQueryParser)

def MultiFieldQueryParser_parse(*args):
  return _lucenepp.MultiFieldQueryParser_parse(*args)
MultiFieldQueryParser_parse = _lucenepp.MultiFieldQueryParser_parse

def MultiFieldQueryParser___cast_(*args):
  return _lucenepp.MultiFieldQueryParser___cast_(*args)
MultiFieldQueryParser___cast_ = _lucenepp.MultiFieldQueryParser___cast_

##########################
# extra compatibility code to make things more familiar...
##########################
import datetime, time

def IndexWriterMaxFieldLength(val):
  return val
IndexWriterMaxFieldLength.LIMITED = IndexWriter.MaxFieldLengthLIMITED
IndexWriterMaxFieldLength.UNLIMITED = IndexWriter.MaxFieldLengthUNLIMITED
IndexWriter.MaxFieldLength = staticmethod(IndexWriterMaxFieldLength)

class AbstractFieldStore():
  YES = AbstractField.STORE_YES
  NO = AbstractField.STORE_NO
AbstractField.Store = AbstractFieldStore
  
class AbstractFieldIndex():
  NO = AbstractField.INDEX_NO
  ANALYZED = AbstractField.INDEX_ANALYZED
  NOT_ANALYZED = AbstractField.INDEX_NOT_ANALYZED
  NOT_ANALYZED_NO_NORMS = AbstractField.INDEX_NOT_ANALYZED_NO_NORMS
  ANALYZED_NO_NORMS = AbstractField.INDEX_ANALYZED_NO_NORMS
AbstractField.Index = AbstractFieldIndex
    
class AbstractFieldTermVector():
  NO = AbstractField.TERM_VECTOR_NO
  YES = AbstractField.TERM_VECTOR_YES
  WITH_POSITIONS = AbstractField.TERM_VECTOR_WITH_POSITIONS
  WITH_OFFSETS = AbstractField.TERM_VECTOR_WITH_OFFSETS
  WITH_POSITIONS_OFFSETS = AbstractField.TERM_VECTOR_WITH_POSITIONS_OFFSETS
AbstractField.TermVector = AbstractFieldTermVector

class BooleanClauseOccur():
  MUST = BooleanClause.MUST
  SHOULD =BooleanClause.SHOULD
  MUST_NOT = BooleanClause.MUST_NOT
BooleanClause.Occur = BooleanClauseOccur

class IndexReaderFieldOption():
  ALL = IndexReader.FIELD_OPTION_ALL
  INDEXED = IndexReader.FIELD_OPTION_INDEXED
  STORES_PAYLOADS = IndexReader.FIELD_OPTION_STORES_PAYLOADS
  OMIT_TERM_FREQ_AND_POSITIONS = IndexReader.FIELD_OPTION_OMIT_TERM_FREQ_AND_POSITIONS
  UNINDEXED = IndexReader.FIELD_OPTION_UNINDEXED
  INDEXED_WITH_TERMVECTOR = IndexReader.FIELD_OPTION_INDEXED_WITH_TERMVECTOR
  INDEXED_NO_TERMVECTOR = IndexReader.FIELD_OPTION_INDEXED_NO_TERMVECTOR
  TERMVECTOR = IndexReader.FIELD_OPTION_TERMVECTOR
  TERMVECTOR_WITH_POSITION = IndexReader.FIELD_OPTION_TERMVECTOR_WITH_POSITION
  TERMVECTOR_WITH_OFFSET = IndexReader.FIELD_OPTION_TERMVECTOR_WITH_OFFSET
  TERMVECTOR_WITH_POSITION_OFFSET = IndexReader.FIELD_OPTION_TERMVECTOR_WITH_POSITION_OFFSET
IndexReader.FieldOption = IndexReaderFieldOption

class QueryParserOperator():
  OR = QueryParser.OR_OPERATOR
  AND = QueryParser.AND_OPERATOR
QueryParser.Operator = QueryParserOperator
def DateTools_dateToString(date, resolution):
  return DateTools.timeToString(int(time.mktime(date.timetuple())), resolution)
DateTools.dateToString = staticmethod(DateTools_dateToString)
def DateTools_stringToDate(string, resolution):
  return datetime.datetime.fromtimestamp(DateTools.stringToTime(string, resolution) / 1000)
DateTools.stringToDate = staticmethod(DateTools_stringToDate)

def DateField_dateToString(date):
  return DateField.timeToString(int(time.mktime(date.timetuple())))
DateField.dateToString = staticmethod(DateField_dateToString)
def DateField_stringToDate(string):
  return datetime.datetime.fromtimestamp(DateField.stringToTime(string) / 1000)
DateField.stringToDate = staticmethod(DateField_stringToDate)

#convert property accessors into real properties
class MakeStaticProperty (property):
    def __get__(self, *args):
      return self.fget()
AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY = MakeStaticProperty(_lucenepp.AttributeFactory_DEFAULT_ATTRIBUTE_FACTORY)
DateField.MIN_DATE_STRING = MakeStaticProperty(_lucenepp.DateField_MIN_DATE_STRING)
DateField.MAX_DATE_STRING = MakeStaticProperty(_lucenepp.DateField_MAX_DATE_STRING)
Token.DEFAULT_TYPE = MakeStaticProperty(_lucenepp.Token_DEFAULT_TYPE)
Token.TOKEN_ATTRIBUTE_FACTORY = MakeStaticProperty(_lucenepp.Token_TOKEN_ATTRIBUTE_FACTORY)
StandardTokenizer.TOKEN_TYPES = MakeStaticProperty(_lucenepp.StandardTokenizer_TOKEN_TYPES)
StopAnalyzer.ENGLISH_STOP_WORDS_SET = MakeStaticProperty(_lucenepp.StopAnalyzer_ENGLISH_STOP_WORDS_SET)
TermVectorOffsetInfo.EMPTY_OFFSET_INFO = MakeStaticProperty(_lucenepp.TermVectorOffsetInfo_EMPTY_OFFSET_INFO)
IndexWriter.MAX_TERM_LENGTH = MakeStaticProperty(_lucenepp.IndexWriter_MAX_TERM_LENGTH)
MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE = MakeStaticProperty(_lucenepp.MultiTermQuery_CONSTANT_SCORE_FILTER_REWRITE)
MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE = MakeStaticProperty(_lucenepp.MultiTermQuery_SCORING_BOOLEAN_QUERY_REWRITE)
MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE = MakeStaticProperty(_lucenepp.MultiTermQuery_CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE)
MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT = MakeStaticProperty(_lucenepp.MultiTermQuery_CONSTANT_SCORE_AUTO_REWRITE_DEFAULT)
DocIdSet.EMPTY_DOCIDSET = MakeStaticProperty(_lucenepp.DocIdSet_EMPTY_DOCIDSET)
FieldCache.DEFAULT = MakeStaticProperty(_lucenepp.FieldCache_DEFAULT)
FieldCache.DEFAULT_BYTE_PARSER = MakeStaticProperty(_lucenepp.FieldCache_DEFAULT_BYTE_PARSER)
FieldCache.DEFAULT_INT_PARSER = MakeStaticProperty(_lucenepp.FieldCache_DEFAULT_INT_PARSER)
FieldCache.DEFAULT_LONG_PARSER = MakeStaticProperty(_lucenepp.FieldCache_DEFAULT_LONG_PARSER)
FieldCache.DEFAULT_DOUBLE_PARSER = MakeStaticProperty(_lucenepp.FieldCache_DEFAULT_DOUBLE_PARSER)
FieldCache.NUMERIC_UTILS_INT_PARSER = MakeStaticProperty(_lucenepp.FieldCache_NUMERIC_UTILS_INT_PARSER)
FieldCache.NUMERIC_UTILS_LONG_PARSER = MakeStaticProperty(_lucenepp.FieldCache_NUMERIC_UTILS_LONG_PARSER)
FieldCache.NUMERIC_UTILS_DOUBLE_PARSER = MakeStaticProperty(_lucenepp.FieldCache_NUMERIC_UTILS_DOUBLE_PARSER)
Sort.RELEVANCE = MakeStaticProperty(_lucenepp.Sort_RELEVANCE)
Sort.INDEXORDER = MakeStaticProperty(_lucenepp.Sort_INDEXORDER)
SortField.FIELD_SCORE = MakeStaticProperty(_lucenepp.SortField_FIELD_SCORE)
SortField.FIELD_DOC = MakeStaticProperty(_lucenepp.SortField_FIELD_DOC)

#dummy code to help PyLucene coders
def initVM():
  pass

def File(path):
  return path