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

"""Codes for working with geo features (e.g. polygons)"""

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _geo
else:
    import _geo

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _geo:
_geo.SwigPyIterator_swigregister(SwigPyIterator)

import seiscomp.math
import seiscomp.core
class GeoCoordinate(object):
    r"""Proxy of C++ Seiscomp::Geo::GeoCoordinate class."""

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

    def __init__(self, *args):
        r"""
        __init__(GeoCoordinate self) -> GeoCoordinate
        __init__(GeoCoordinate self, Seiscomp::Geo::GeoCoordinate::ValueType lat_, Seiscomp::Geo::GeoCoordinate::ValueType lon_) -> GeoCoordinate
        """
        _geo.GeoCoordinate_swiginit(self, _geo.new_GeoCoordinate(*args))

    def set(self, lat, lon):
        r"""set(GeoCoordinate self, Seiscomp::Geo::GeoCoordinate::ValueType lat, Seiscomp::Geo::GeoCoordinate::ValueType lon)"""
        return _geo.GeoCoordinate_set(self, lat, lon)

    def latitude(self):
        r"""latitude(GeoCoordinate self) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
        return _geo.GeoCoordinate_latitude(self)

    def longitude(self):
        r"""longitude(GeoCoordinate self) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
        return _geo.GeoCoordinate_longitude(self)

    def __eq__(self, other):
        r"""__eq__(GeoCoordinate self, GeoCoordinate other) -> bool"""
        return _geo.GeoCoordinate___eq__(self, other)

    def __ne__(self, other):
        r"""__ne__(GeoCoordinate self, GeoCoordinate other) -> bool"""
        return _geo.GeoCoordinate___ne__(self, other)

    def normalize(self):
        r"""normalize(GeoCoordinate self) -> GeoCoordinate"""
        return _geo.GeoCoordinate_normalize(self)

    @staticmethod
    def width(lon0, lon1):
        r"""width(Seiscomp::Geo::GeoCoordinate::ValueType lon0, Seiscomp::Geo::GeoCoordinate::ValueType lon1) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
        return _geo.GeoCoordinate_width(lon0, lon1)

    @staticmethod
    def normalizeLat(lat):
        r"""normalizeLat(Seiscomp::Geo::GeoCoordinate::ValueType lat) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
        return _geo.GeoCoordinate_normalizeLat(lat)

    @staticmethod
    def normalizeLon(lon):
        r"""normalizeLon(Seiscomp::Geo::GeoCoordinate::ValueType lon) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
        return _geo.GeoCoordinate_normalizeLon(lon)

    @staticmethod
    def normalizeLatLon(lat, lon):
        r"""normalizeLatLon(Seiscomp::Geo::GeoCoordinate::ValueType & lat, Seiscomp::Geo::GeoCoordinate::ValueType & lon)"""
        return _geo.GeoCoordinate_normalizeLatLon(lat, lon)

    @staticmethod
    def distanceLon(lon0, lon1):
        r"""distanceLon(Seiscomp::Geo::GeoCoordinate::ValueType lon0, Seiscomp::Geo::GeoCoordinate::ValueType lon1) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
        return _geo.GeoCoordinate_distanceLon(lon0, lon1)
    lat = property(_geo.GeoCoordinate_lat_get, _geo.GeoCoordinate_lat_set, doc=r"""lat : Seiscomp::Geo::GeoCoordinate::ValueType""")
    lon = property(_geo.GeoCoordinate_lon_get, _geo.GeoCoordinate_lon_set, doc=r"""lon : Seiscomp::Geo::GeoCoordinate::ValueType""")
    __swig_destroy__ = _geo.delete_GeoCoordinate

# Register GeoCoordinate in _geo:
_geo.GeoCoordinate_swigregister(GeoCoordinate)

def GeoCoordinate_width(lon0, lon1):
    r"""GeoCoordinate_width(Seiscomp::Geo::GeoCoordinate::ValueType lon0, Seiscomp::Geo::GeoCoordinate::ValueType lon1) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
    return _geo.GeoCoordinate_width(lon0, lon1)

def GeoCoordinate_normalizeLat(lat):
    r"""GeoCoordinate_normalizeLat(Seiscomp::Geo::GeoCoordinate::ValueType lat) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
    return _geo.GeoCoordinate_normalizeLat(lat)

def GeoCoordinate_normalizeLon(lon):
    r"""GeoCoordinate_normalizeLon(Seiscomp::Geo::GeoCoordinate::ValueType lon) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
    return _geo.GeoCoordinate_normalizeLon(lon)

def GeoCoordinate_normalizeLatLon(lat, lon):
    r"""GeoCoordinate_normalizeLatLon(Seiscomp::Geo::GeoCoordinate::ValueType & lat, Seiscomp::Geo::GeoCoordinate::ValueType & lon)"""
    return _geo.GeoCoordinate_normalizeLatLon(lat, lon)

def GeoCoordinate_distanceLon(lon0, lon1):
    r"""GeoCoordinate_distanceLon(Seiscomp::Geo::GeoCoordinate::ValueType lon0, Seiscomp::Geo::GeoCoordinate::ValueType lon1) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
    return _geo.GeoCoordinate_distanceLon(lon0, lon1)


def contains(*args):
    r"""
    contains(GeoCoordinate v, GeoCoordinate polygon, size_t sides) -> bool
    contains(GeoCoordinate v, GeoCoordinate polygon, size_t sides, double & area) -> bool
    """
    return _geo.contains(*args)

def area(polygon, sides):
    r"""area(GeoCoordinate polygon, size_t sides) -> double"""
    return _geo.area(polygon, sides)
class formatted_lat(object):
    r"""Proxy of C++ Seiscomp::Geo::formatted_lat class."""

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

    def __init__(self, lat):
        r"""__init__(formatted_lat self, double lat) -> formatted_lat"""
        _geo.formatted_lat_swiginit(self, _geo.new_formatted_lat(lat))
    v = property(_geo.formatted_lat_v_get, _geo.formatted_lat_v_set, doc=r"""v : double""")
    __swig_destroy__ = _geo.delete_formatted_lat

# Register formatted_lat in _geo:
_geo.formatted_lat_swigregister(formatted_lat)

class formatted_lon(object):
    r"""Proxy of C++ Seiscomp::Geo::formatted_lon class."""

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

    def __init__(self, lon):
        r"""__init__(formatted_lon self, double lon) -> formatted_lon"""
        _geo.formatted_lon_swiginit(self, _geo.new_formatted_lon(lon))
    v = property(_geo.formatted_lon_v_get, _geo.formatted_lon_v_set, doc=r"""v : double""")
    __swig_destroy__ = _geo.delete_formatted_lon

# Register formatted_lon in _geo:
_geo.formatted_lon_swigregister(formatted_lon)

class GeoBoundingBox(object):
    r"""Proxy of C++ Seiscomp::Geo::GeoBoundingBox class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Disjunct = _geo.GeoBoundingBox_Disjunct
    
    Contains = _geo.GeoBoundingBox_Contains
    
    Intersects = _geo.GeoBoundingBox_Intersects
    

    def __init__(self, *args):
        r"""
        __init__(GeoBoundingBox self) -> GeoBoundingBox
        __init__(GeoBoundingBox self, Seiscomp::Geo::GeoBoundingBox::ValueType south, Seiscomp::Geo::GeoBoundingBox::ValueType west, Seiscomp::Geo::GeoBoundingBox::ValueType north, Seiscomp::Geo::GeoBoundingBox::ValueType east) -> GeoBoundingBox
        """
        _geo.GeoBoundingBox_swiginit(self, _geo.new_GeoBoundingBox(*args))

    def __eq__(self, other):
        r"""__eq__(GeoBoundingBox self, GeoBoundingBox other) -> bool"""
        return _geo.GeoBoundingBox___eq__(self, other)

    def __iadd__(self, other):
        r"""__iadd__(GeoBoundingBox self, GeoBoundingBox other) -> GeoBoundingBox"""
        return _geo.GeoBoundingBox___iadd__(self, other)

    def __add__(self, other):
        r"""__add__(GeoBoundingBox self, GeoBoundingBox other) -> GeoBoundingBox"""
        return _geo.GeoBoundingBox___add__(self, other)

    def __and__(self, other):
        r"""__and__(GeoBoundingBox self, GeoBoundingBox other) -> bool"""
        return _geo.GeoBoundingBox___and__(self, other)

    def normalize(self):
        r"""normalize(GeoBoundingBox self) -> GeoBoundingBox"""
        return _geo.GeoBoundingBox_normalize(self)

    def isEmpty(self):
        r"""isEmpty(GeoBoundingBox self) -> bool"""
        return _geo.GeoBoundingBox_isEmpty(self)

    def isNull(self):
        r"""isNull(GeoBoundingBox self) -> bool"""
        return _geo.GeoBoundingBox_isNull(self)

    def reset(self):
        r"""reset(GeoBoundingBox self)"""
        return _geo.GeoBoundingBox_reset(self)

    def coversFullLongitude(self):
        r"""coversFullLongitude(GeoBoundingBox self) -> bool"""
        return _geo.GeoBoundingBox_coversFullLongitude(self)

    def width(self):
        r"""width(GeoBoundingBox self) -> Seiscomp::Geo::GeoBoundingBox::ValueType"""
        return _geo.GeoBoundingBox_width(self)

    def height(self):
        r"""height(GeoBoundingBox self) -> Seiscomp::Geo::GeoBoundingBox::ValueType"""
        return _geo.GeoBoundingBox_height(self)

    @staticmethod
    def crossesDateLine(*args):
        r"""
        crossesDateLine() -> bool
        crossesDateLine(Seiscomp::Geo::GeoBoundingBox::ValueType east, Seiscomp::Geo::GeoBoundingBox::ValueType west) -> bool
        """
        return _geo.GeoBoundingBox_crossesDateLine(*args)

    def center(self):
        r"""center(GeoBoundingBox self) -> GeoCoordinate"""
        return _geo.GeoBoundingBox_center(self)

    def contains(self, *args):
        r"""
        contains(GeoBoundingBox self, GeoCoordinate v) -> bool
        contains(GeoBoundingBox self, GeoBoundingBox other) -> bool
        """
        return _geo.GeoBoundingBox_contains(self, *args)

    def relation(self, other):
        r"""relation(GeoBoundingBox self, GeoBoundingBox other) -> Seiscomp::Geo::GeoBoundingBox::Relation"""
        return _geo.GeoBoundingBox_relation(self, other)

    def merge(self, other):
        r"""merge(GeoBoundingBox self, GeoBoundingBox other)"""
        return _geo.GeoBoundingBox_merge(self, other)

    def intersects(self, other):
        r"""intersects(GeoBoundingBox self, GeoBoundingBox other) -> bool"""
        return _geo.GeoBoundingBox_intersects(self, other)

    def fromPolygon(self, n, coords, isClosed=True):
        r"""fromPolygon(GeoBoundingBox self, size_t n, GeoCoordinate coords, bool isClosed=True)"""
        return _geo.GeoBoundingBox_fromPolygon(self, n, coords, isClosed)
    Empty = property(_geo.GeoBoundingBox_Empty_get, _geo.GeoBoundingBox_Empty_set, doc=r"""Empty : Seiscomp::Geo::GeoBoundingBox""")
    __swig_destroy__ = _geo.delete_GeoBoundingBox

# Register GeoBoundingBox in _geo:
_geo.GeoBoundingBox_swigregister(GeoBoundingBox)

def GeoBoundingBox_crossesDateLine(*args):
    r"""
    GeoBoundingBox_crossesDateLine() -> bool
    GeoBoundingBox_crossesDateLine(Seiscomp::Geo::GeoBoundingBox::ValueType east, Seiscomp::Geo::GeoBoundingBox::ValueType west) -> bool
    """
    return _geo.GeoBoundingBox_crossesDateLine(*args)
cvar = _geo.cvar


def __lshift__(*args):
    r"""
    __lshift__(std::ostream & os, GeoCoordinate arg2) -> std::ostream
    __lshift__(std::ostream & os, formatted_lat arg2) -> std::ostream
    __lshift__(std::ostream & os, formatted_lon arg2) -> std::ostream
    __lshift__(std::ostream & os, GeoBoundingBox box) -> std::ostream &
    """
    return _geo.__lshift__(*args)
class Category(object):
    r"""Proxy of C++ Seiscomp::Geo::Category class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    id = property(_geo.Category_id_get, _geo.Category_id_set, doc=r"""id : unsigned int""")
    name = property(_geo.Category_name_get, _geo.Category_name_set, doc=r"""name : std::string""")
    localName = property(_geo.Category_localName_get, _geo.Category_localName_set, doc=r"""localName : std::string""")
    parent = property(_geo.Category_parent_get, _geo.Category_parent_set, doc=r"""parent : p.q(const).Seiscomp::Geo::Category""")
    dataDir = property(_geo.Category_dataDir_get, _geo.Category_dataDir_set, doc=r"""dataDir : std::string""")

    def __init__(self, *args):
        r"""__init__(Category self, unsigned int id, std::string name="", Category parent=None) -> Category"""
        _geo.Category_swiginit(self, _geo.new_Category(*args))
    __swig_destroy__ = _geo.delete_Category

# Register Category in _geo:
_geo.Category_swigregister(Category)

class GeoFeature(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Geo::GeoFeature class."""

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

    def __init__(self, *args):
        r"""
        __init__(GeoFeature self, Category category=None, unsigned int rank=1) -> GeoFeature
        __init__(GeoFeature self, std::string const & name, Category category, unsigned int rank) -> GeoFeature
        __init__(GeoFeature self, std::string const & name, Category category, unsigned int rank, Seiscomp::Geo::GeoFeature::Attributes const & attributes) -> GeoFeature
        """
        _geo.GeoFeature_swiginit(self, _geo.new_GeoFeature(*args))
    __swig_destroy__ = _geo.delete_GeoFeature

    def setName(self, name):
        r"""setName(GeoFeature self, std::string const & name)"""
        return _geo.GeoFeature_setName(self, name)

    def name(self):
        r"""name(GeoFeature self) -> std::string const &"""
        return _geo.GeoFeature_name(self)

    def category(self):
        r"""category(GeoFeature self) -> Category"""
        return _geo.GeoFeature_category(self)

    def setRank(self, rank):
        r"""setRank(GeoFeature self, unsigned int rank)"""
        return _geo.GeoFeature_setRank(self, rank)

    def rank(self):
        r"""rank(GeoFeature self) -> unsigned int"""
        return _geo.GeoFeature_rank(self)

    def setAttribute(self, name, value):
        r"""setAttribute(GeoFeature self, std::string const & name, std::string const & value)"""
        return _geo.GeoFeature_setAttribute(self, name, value)

    def attributes(self):
        r"""attributes(GeoFeature self) -> Seiscomp::Geo::GeoFeature::Attributes const &"""
        return _geo.GeoFeature_attributes(self)

    def addVertex(self, *args):
        r"""
        addVertex(GeoFeature self, GeoCoordinate vertex, bool newSubFeature=False)
        addVertex(GeoFeature self, float lat, float lon, bool newSubFeature=False)
        """
        return _geo.GeoFeature_addVertex(self, *args)

    def closedPolygon(self):
        r"""closedPolygon(GeoFeature self) -> bool"""
        return _geo.GeoFeature_closedPolygon(self)

    def setClosedPolygon(self, closed):
        r"""setClosedPolygon(GeoFeature self, bool closed)"""
        return _geo.GeoFeature_setClosedPolygon(self, closed)

    def updateBoundingBox(self):
        r"""updateBoundingBox(GeoFeature self)"""
        return _geo.GeoFeature_updateBoundingBox(self)

    def invertOrder(self):
        r"""invertOrder(GeoFeature self)"""
        return _geo.GeoFeature_invertOrder(self)

    def sort(self):
        r"""sort(GeoFeature self)"""
        return _geo.GeoFeature_sort(self)

    def setUserData(self, arg2):
        r"""setUserData(GeoFeature self, void * arg2)"""
        return _geo.GeoFeature_setUserData(self, arg2)

    def userData(self):
        r"""userData(GeoFeature self) -> void *"""
        return _geo.GeoFeature_userData(self)

    def vertices(self):
        r"""vertices(GeoFeature self) -> Vertices"""
        return _geo.GeoFeature_vertices(self)

    def bbox(self):
        r"""bbox(GeoFeature self) -> GeoBoundingBox"""
        return _geo.GeoFeature_bbox(self)

    def subFeatures(self):
        r"""subFeatures(GeoFeature self) -> Indexes"""
        return _geo.GeoFeature_subFeatures(self)

    def contains(self, v):
        r"""contains(GeoFeature self, GeoCoordinate v) -> bool"""
        return _geo.GeoFeature_contains(self, v)

    @staticmethod
    def area(*args):
        r"""
        area() -> double
        area(GeoCoordinate polygon, size_t sides) -> double
        """
        return _geo.GeoFeature_area(*args)

# Register GeoFeature in _geo:
_geo.GeoFeature_swigregister(GeoFeature)

def GeoFeature_area(*args):
    r"""
    GeoFeature_area() -> double
    GeoFeature_area(GeoCoordinate polygon, size_t sides) -> double
    """
    return _geo.GeoFeature_area(*args)

class GeoFeatureSetObserver(object):
    r"""Proxy of C++ Seiscomp::Geo::GeoFeatureSetObserver class."""

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

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

    def geoFeatureSetUpdated(self):
        r"""geoFeatureSetUpdated(GeoFeatureSetObserver self)"""
        return _geo.GeoFeatureSetObserver_geoFeatureSetUpdated(self)

# Register GeoFeatureSetObserver in _geo:
_geo.GeoFeatureSetObserver_swigregister(GeoFeatureSetObserver)

class GeoFeatureSet(seiscomp.core.BaseObject):
    r"""Proxy of C++ Seiscomp::Geo::GeoFeatureSet class."""

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

    def __init__(self):
        r"""__init__(GeoFeatureSet self) -> GeoFeatureSet"""
        _geo.GeoFeatureSet_swiginit(self, _geo.new_GeoFeatureSet())
    __swig_destroy__ = _geo.delete_GeoFeatureSet

    def registerObserver(self, arg2):
        r"""registerObserver(GeoFeatureSet self, GeoFeatureSetObserver arg2) -> bool"""
        return _geo.GeoFeatureSet_registerObserver(self, arg2)

    def unregisterObserver(self, arg2):
        r"""unregisterObserver(GeoFeatureSet self, GeoFeatureSetObserver arg2) -> bool"""
        return _geo.GeoFeatureSet_unregisterObserver(self, arg2)

    def clear(self):
        r"""clear(GeoFeatureSet self)"""
        return _geo.GeoFeatureSet_clear(self)

    def load(self):
        r"""load(GeoFeatureSet self)"""
        return _geo.GeoFeatureSet_load(self)

    def readBNADir(self, dirPath):
        r"""readBNADir(GeoFeatureSet self, std::string const & dirPath) -> size_t"""
        return _geo.GeoFeatureSet_readBNADir(self, dirPath)

    def readBNAFile(self, filename, category):
        r"""readBNAFile(GeoFeatureSet self, std::string const & filename, Category category) -> bool"""
        return _geo.GeoFeatureSet_readBNAFile(self, filename, category)

    def readDir(self, dirPath):
        r"""readDir(GeoFeatureSet self, std::string const & dirPath) -> size_t"""
        return _geo.GeoFeatureSet_readDir(self, dirPath)

    def readFile(self, filename, category):
        r"""readFile(GeoFeatureSet self, std::string const & filename, Category category) -> ssize_t"""
        return _geo.GeoFeatureSet_readFile(self, filename, category)

    def addFeature(self, feature):
        r"""addFeature(GeoFeatureSet self, GeoFeature feature) -> bool"""
        return _geo.GeoFeatureSet_addFeature(self, feature)

    def features(self):
        r"""features(GeoFeatureSet self) -> GeoFeatures"""
        return _geo.GeoFeatureSet_features(self)

    def categories(self):
        r"""categories(GeoFeatureSet self) -> Categories"""
        return _geo.GeoFeatureSet_categories(self)

# Register GeoFeatureSet in _geo:
_geo.GeoFeatureSet_swigregister(GeoFeatureSet)

class GeoFeatureSetSingleton(object):
    r"""Proxy of C++ Seiscomp::Geo::GeoFeatureSetSingleton class."""

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

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

    @staticmethod
    def getInstance():
        r"""getInstance() -> GeoFeatureSet"""
        return _geo.GeoFeatureSetSingleton_getInstance()
    __swig_destroy__ = _geo.delete_GeoFeatureSetSingleton

# Register GeoFeatureSetSingleton in _geo:
_geo.GeoFeatureSetSingleton_swigregister(GeoFeatureSetSingleton)

def GeoFeatureSetSingleton_getInstance():
    r"""GeoFeatureSetSingleton_getInstance() -> GeoFeatureSet"""
    return _geo.GeoFeatureSetSingleton_getInstance()

class Categories(object):
    r"""Proxy of C++ std::vector< Seiscomp::Geo::Category * > class."""

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

    def iterator(self):
        r"""iterator(Categories self) -> SwigPyIterator"""
        return _geo.Categories_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(Categories self) -> bool"""
        return _geo.Categories___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Categories self) -> bool"""
        return _geo.Categories___bool__(self)

    def __len__(self):
        r"""__len__(Categories self) -> std::vector< Seiscomp::Geo::Category * >::size_type"""
        return _geo.Categories___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i, std::vector< Seiscomp::Geo::Category * >::difference_type j) -> Categories"""
        return _geo.Categories___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i, std::vector< Seiscomp::Geo::Category * >::difference_type j)
        __setslice__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i, std::vector< Seiscomp::Geo::Category * >::difference_type j, Categories v)
        """
        return _geo.Categories___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i, std::vector< Seiscomp::Geo::Category * >::difference_type j)"""
        return _geo.Categories___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i)
        __delitem__(Categories self, PySliceObject * slice)
        """
        return _geo.Categories___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(Categories self, PySliceObject * slice) -> Categories
        __getitem__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i) -> Category
        """
        return _geo.Categories___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(Categories self, PySliceObject * slice, Categories v)
        __setitem__(Categories self, PySliceObject * slice)
        __setitem__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i, Category x)
        """
        return _geo.Categories___setitem__(self, *args)

    def pop(self):
        r"""pop(Categories self) -> Category"""
        return _geo.Categories_pop(self)

    def append(self, x):
        r"""append(Categories self, Category x)"""
        return _geo.Categories_append(self, x)

    def empty(self):
        r"""empty(Categories self) -> bool"""
        return _geo.Categories_empty(self)

    def size(self):
        r"""size(Categories self) -> std::vector< Seiscomp::Geo::Category * >::size_type"""
        return _geo.Categories_size(self)

    def swap(self, v):
        r"""swap(Categories self, Categories v)"""
        return _geo.Categories_swap(self, v)

    def begin(self):
        r"""begin(Categories self) -> std::vector< Seiscomp::Geo::Category * >::iterator"""
        return _geo.Categories_begin(self)

    def end(self):
        r"""end(Categories self) -> std::vector< Seiscomp::Geo::Category * >::iterator"""
        return _geo.Categories_end(self)

    def rbegin(self):
        r"""rbegin(Categories self) -> std::vector< Seiscomp::Geo::Category * >::reverse_iterator"""
        return _geo.Categories_rbegin(self)

    def rend(self):
        r"""rend(Categories self) -> std::vector< Seiscomp::Geo::Category * >::reverse_iterator"""
        return _geo.Categories_rend(self)

    def clear(self):
        r"""clear(Categories self)"""
        return _geo.Categories_clear(self)

    def get_allocator(self):
        r"""get_allocator(Categories self) -> std::vector< Seiscomp::Geo::Category * >::allocator_type"""
        return _geo.Categories_get_allocator(self)

    def pop_back(self):
        r"""pop_back(Categories self)"""
        return _geo.Categories_pop_back(self)

    def erase(self, *args):
        r"""
        erase(Categories self, std::vector< Seiscomp::Geo::Category * >::iterator pos) -> std::vector< Seiscomp::Geo::Category * >::iterator
        erase(Categories self, std::vector< Seiscomp::Geo::Category * >::iterator first, std::vector< Seiscomp::Geo::Category * >::iterator last) -> std::vector< Seiscomp::Geo::Category * >::iterator
        """
        return _geo.Categories_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(Categories self) -> Categories
        __init__(Categories self, Categories other) -> Categories
        __init__(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type size) -> Categories
        __init__(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type size, Category value) -> Categories
        """
        _geo.Categories_swiginit(self, _geo.new_Categories(*args))

    def push_back(self, x):
        r"""push_back(Categories self, Category x)"""
        return _geo.Categories_push_back(self, x)

    def front(self):
        r"""front(Categories self) -> Category"""
        return _geo.Categories_front(self)

    def back(self):
        r"""back(Categories self) -> Category"""
        return _geo.Categories_back(self)

    def assign(self, n, x):
        r"""assign(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type n, Category x)"""
        return _geo.Categories_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type new_size)
        resize(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type new_size, Category x)
        """
        return _geo.Categories_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(Categories self, std::vector< Seiscomp::Geo::Category * >::iterator pos, Category x) -> std::vector< Seiscomp::Geo::Category * >::iterator
        insert(Categories self, std::vector< Seiscomp::Geo::Category * >::iterator pos, std::vector< Seiscomp::Geo::Category * >::size_type n, Category x)
        """
        return _geo.Categories_insert(self, *args)

    def reserve(self, n):
        r"""reserve(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type n)"""
        return _geo.Categories_reserve(self, n)

    def capacity(self):
        r"""capacity(Categories self) -> std::vector< Seiscomp::Geo::Category * >::size_type"""
        return _geo.Categories_capacity(self)
    __swig_destroy__ = _geo.delete_Categories

# Register Categories in _geo:
_geo.Categories_swigregister(Categories)

class GeoFeatures(object):
    r"""Proxy of C++ std::vector< Seiscomp::Geo::GeoFeature * > class."""

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

    def iterator(self):
        r"""iterator(GeoFeatures self) -> SwigPyIterator"""
        return _geo.GeoFeatures_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(GeoFeatures self) -> bool"""
        return _geo.GeoFeatures___nonzero__(self)

    def __bool__(self):
        r"""__bool__(GeoFeatures self) -> bool"""
        return _geo.GeoFeatures___bool__(self)

    def __len__(self):
        r"""__len__(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::size_type"""
        return _geo.GeoFeatures___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type j) -> GeoFeatures"""
        return _geo.GeoFeatures___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type j)
        __setslice__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type j, GeoFeatures v)
        """
        return _geo.GeoFeatures___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type j)"""
        return _geo.GeoFeatures___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i)
        __delitem__(GeoFeatures self, PySliceObject * slice)
        """
        return _geo.GeoFeatures___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(GeoFeatures self, PySliceObject * slice) -> GeoFeatures
        __getitem__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i) -> GeoFeature
        """
        return _geo.GeoFeatures___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(GeoFeatures self, PySliceObject * slice, GeoFeatures v)
        __setitem__(GeoFeatures self, PySliceObject * slice)
        __setitem__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i, GeoFeature x)
        """
        return _geo.GeoFeatures___setitem__(self, *args)

    def pop(self):
        r"""pop(GeoFeatures self) -> GeoFeature"""
        return _geo.GeoFeatures_pop(self)

    def append(self, x):
        r"""append(GeoFeatures self, GeoFeature x)"""
        return _geo.GeoFeatures_append(self, x)

    def empty(self):
        r"""empty(GeoFeatures self) -> bool"""
        return _geo.GeoFeatures_empty(self)

    def size(self):
        r"""size(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::size_type"""
        return _geo.GeoFeatures_size(self)

    def swap(self, v):
        r"""swap(GeoFeatures self, GeoFeatures v)"""
        return _geo.GeoFeatures_swap(self, v)

    def begin(self):
        r"""begin(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::iterator"""
        return _geo.GeoFeatures_begin(self)

    def end(self):
        r"""end(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::iterator"""
        return _geo.GeoFeatures_end(self)

    def rbegin(self):
        r"""rbegin(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::reverse_iterator"""
        return _geo.GeoFeatures_rbegin(self)

    def rend(self):
        r"""rend(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::reverse_iterator"""
        return _geo.GeoFeatures_rend(self)

    def clear(self):
        r"""clear(GeoFeatures self)"""
        return _geo.GeoFeatures_clear(self)

    def get_allocator(self):
        r"""get_allocator(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::allocator_type"""
        return _geo.GeoFeatures_get_allocator(self)

    def pop_back(self):
        r"""pop_back(GeoFeatures self)"""
        return _geo.GeoFeatures_pop_back(self)

    def erase(self, *args):
        r"""
        erase(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::iterator pos) -> std::vector< Seiscomp::Geo::GeoFeature * >::iterator
        erase(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::iterator first, std::vector< Seiscomp::Geo::GeoFeature * >::iterator last) -> std::vector< Seiscomp::Geo::GeoFeature * >::iterator
        """
        return _geo.GeoFeatures_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(GeoFeatures self) -> GeoFeatures
        __init__(GeoFeatures self, GeoFeatures other) -> GeoFeatures
        __init__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type size) -> GeoFeatures
        __init__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type size, GeoFeature value) -> GeoFeatures
        """
        _geo.GeoFeatures_swiginit(self, _geo.new_GeoFeatures(*args))

    def push_back(self, x):
        r"""push_back(GeoFeatures self, GeoFeature x)"""
        return _geo.GeoFeatures_push_back(self, x)

    def front(self):
        r"""front(GeoFeatures self) -> GeoFeature"""
        return _geo.GeoFeatures_front(self)

    def back(self):
        r"""back(GeoFeatures self) -> GeoFeature"""
        return _geo.GeoFeatures_back(self)

    def assign(self, n, x):
        r"""assign(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type n, GeoFeature x)"""
        return _geo.GeoFeatures_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type new_size)
        resize(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type new_size, GeoFeature x)
        """
        return _geo.GeoFeatures_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::iterator pos, GeoFeature x) -> std::vector< Seiscomp::Geo::GeoFeature * >::iterator
        insert(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::iterator pos, std::vector< Seiscomp::Geo::GeoFeature * >::size_type n, GeoFeature x)
        """
        return _geo.GeoFeatures_insert(self, *args)

    def reserve(self, n):
        r"""reserve(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type n)"""
        return _geo.GeoFeatures_reserve(self, n)

    def capacity(self):
        r"""capacity(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::size_type"""
        return _geo.GeoFeatures_capacity(self)
    __swig_destroy__ = _geo.delete_GeoFeatures

# Register GeoFeatures in _geo:
_geo.GeoFeatures_swigregister(GeoFeatures)

class Vertices(object):
    r"""Proxy of C++ std::vector< Seiscomp::Geo::GeoCoordinate > class."""

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

    def iterator(self):
        r"""iterator(Vertices self) -> SwigPyIterator"""
        return _geo.Vertices_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(Vertices self) -> bool"""
        return _geo.Vertices___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Vertices self) -> bool"""
        return _geo.Vertices___bool__(self)

    def __len__(self):
        r"""__len__(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::size_type"""
        return _geo.Vertices___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type j) -> Vertices"""
        return _geo.Vertices___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type j)
        __setslice__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type j, Vertices v)
        """
        return _geo.Vertices___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type j)"""
        return _geo.Vertices___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i)
        __delitem__(Vertices self, PySliceObject * slice)
        """
        return _geo.Vertices___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(Vertices self, PySliceObject * slice) -> Vertices
        __getitem__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i) -> GeoCoordinate
        """
        return _geo.Vertices___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(Vertices self, PySliceObject * slice, Vertices v)
        __setitem__(Vertices self, PySliceObject * slice)
        __setitem__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i, GeoCoordinate x)
        """
        return _geo.Vertices___setitem__(self, *args)

    def pop(self):
        r"""pop(Vertices self) -> GeoCoordinate"""
        return _geo.Vertices_pop(self)

    def append(self, x):
        r"""append(Vertices self, GeoCoordinate x)"""
        return _geo.Vertices_append(self, x)

    def empty(self):
        r"""empty(Vertices self) -> bool"""
        return _geo.Vertices_empty(self)

    def size(self):
        r"""size(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::size_type"""
        return _geo.Vertices_size(self)

    def swap(self, v):
        r"""swap(Vertices self, Vertices v)"""
        return _geo.Vertices_swap(self, v)

    def begin(self):
        r"""begin(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::iterator"""
        return _geo.Vertices_begin(self)

    def end(self):
        r"""end(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::iterator"""
        return _geo.Vertices_end(self)

    def rbegin(self):
        r"""rbegin(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::reverse_iterator"""
        return _geo.Vertices_rbegin(self)

    def rend(self):
        r"""rend(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::reverse_iterator"""
        return _geo.Vertices_rend(self)

    def clear(self):
        r"""clear(Vertices self)"""
        return _geo.Vertices_clear(self)

    def get_allocator(self):
        r"""get_allocator(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::allocator_type"""
        return _geo.Vertices_get_allocator(self)

    def pop_back(self):
        r"""pop_back(Vertices self)"""
        return _geo.Vertices_pop_back(self)

    def erase(self, *args):
        r"""
        erase(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::iterator pos) -> std::vector< Seiscomp::Geo::GeoCoordinate >::iterator
        erase(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::iterator first, std::vector< Seiscomp::Geo::GeoCoordinate >::iterator last) -> std::vector< Seiscomp::Geo::GeoCoordinate >::iterator
        """
        return _geo.Vertices_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(Vertices self) -> Vertices
        __init__(Vertices self, Vertices other) -> Vertices
        __init__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type size) -> Vertices
        __init__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type size, GeoCoordinate value) -> Vertices
        """
        _geo.Vertices_swiginit(self, _geo.new_Vertices(*args))

    def push_back(self, x):
        r"""push_back(Vertices self, GeoCoordinate x)"""
        return _geo.Vertices_push_back(self, x)

    def front(self):
        r"""front(Vertices self) -> GeoCoordinate"""
        return _geo.Vertices_front(self)

    def back(self):
        r"""back(Vertices self) -> GeoCoordinate"""
        return _geo.Vertices_back(self)

    def assign(self, n, x):
        r"""assign(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type n, GeoCoordinate x)"""
        return _geo.Vertices_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type new_size)
        resize(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type new_size, GeoCoordinate x)
        """
        return _geo.Vertices_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::iterator pos, GeoCoordinate x) -> std::vector< Seiscomp::Geo::GeoCoordinate >::iterator
        insert(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::iterator pos, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type n, GeoCoordinate x)
        """
        return _geo.Vertices_insert(self, *args)

    def reserve(self, n):
        r"""reserve(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type n)"""
        return _geo.Vertices_reserve(self, n)

    def capacity(self):
        r"""capacity(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::size_type"""
        return _geo.Vertices_capacity(self)
    __swig_destroy__ = _geo.delete_Vertices

# Register Vertices in _geo:
_geo.Vertices_swigregister(Vertices)

class Indexes(object):
    r"""Proxy of C++ std::vector< size_t > class."""

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

    def iterator(self):
        r"""iterator(Indexes self) -> SwigPyIterator"""
        return _geo.Indexes_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(Indexes self) -> bool"""
        return _geo.Indexes___nonzero__(self)

    def __bool__(self):
        r"""__bool__(Indexes self) -> bool"""
        return _geo.Indexes___bool__(self)

    def __len__(self):
        r"""__len__(Indexes self) -> std::vector< size_t >::size_type"""
        return _geo.Indexes___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(Indexes self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j) -> Indexes"""
        return _geo.Indexes___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(Indexes self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j)
        __setslice__(Indexes self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j, Indexes v)
        """
        return _geo.Indexes___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(Indexes self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j)"""
        return _geo.Indexes___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(Indexes self, std::vector< size_t >::difference_type i)
        __delitem__(Indexes self, PySliceObject * slice)
        """
        return _geo.Indexes___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(Indexes self, PySliceObject * slice) -> Indexes
        __getitem__(Indexes self, std::vector< size_t >::difference_type i) -> std::vector< size_t >::value_type const &
        """
        return _geo.Indexes___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(Indexes self, PySliceObject * slice, Indexes v)
        __setitem__(Indexes self, PySliceObject * slice)
        __setitem__(Indexes self, std::vector< size_t >::difference_type i, std::vector< size_t >::value_type const & x)
        """
        return _geo.Indexes___setitem__(self, *args)

    def pop(self):
        r"""pop(Indexes self) -> std::vector< size_t >::value_type"""
        return _geo.Indexes_pop(self)

    def append(self, x):
        r"""append(Indexes self, std::vector< size_t >::value_type const & x)"""
        return _geo.Indexes_append(self, x)

    def empty(self):
        r"""empty(Indexes self) -> bool"""
        return _geo.Indexes_empty(self)

    def size(self):
        r"""size(Indexes self) -> std::vector< size_t >::size_type"""
        return _geo.Indexes_size(self)

    def swap(self, v):
        r"""swap(Indexes self, Indexes v)"""
        return _geo.Indexes_swap(self, v)

    def begin(self):
        r"""begin(Indexes self) -> std::vector< size_t >::iterator"""
        return _geo.Indexes_begin(self)

    def end(self):
        r"""end(Indexes self) -> std::vector< size_t >::iterator"""
        return _geo.Indexes_end(self)

    def rbegin(self):
        r"""rbegin(Indexes self) -> std::vector< size_t >::reverse_iterator"""
        return _geo.Indexes_rbegin(self)

    def rend(self):
        r"""rend(Indexes self) -> std::vector< size_t >::reverse_iterator"""
        return _geo.Indexes_rend(self)

    def clear(self):
        r"""clear(Indexes self)"""
        return _geo.Indexes_clear(self)

    def get_allocator(self):
        r"""get_allocator(Indexes self) -> std::vector< size_t >::allocator_type"""
        return _geo.Indexes_get_allocator(self)

    def pop_back(self):
        r"""pop_back(Indexes self)"""
        return _geo.Indexes_pop_back(self)

    def erase(self, *args):
        r"""
        erase(Indexes self, std::vector< size_t >::iterator pos) -> std::vector< size_t >::iterator
        erase(Indexes self, std::vector< size_t >::iterator first, std::vector< size_t >::iterator last) -> std::vector< size_t >::iterator
        """
        return _geo.Indexes_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(Indexes self) -> Indexes
        __init__(Indexes self, Indexes other) -> Indexes
        __init__(Indexes self, std::vector< size_t >::size_type size) -> Indexes
        __init__(Indexes self, std::vector< size_t >::size_type size, std::vector< size_t >::value_type const & value) -> Indexes
        """
        _geo.Indexes_swiginit(self, _geo.new_Indexes(*args))

    def push_back(self, x):
        r"""push_back(Indexes self, std::vector< size_t >::value_type const & x)"""
        return _geo.Indexes_push_back(self, x)

    def front(self):
        r"""front(Indexes self) -> std::vector< size_t >::value_type const &"""
        return _geo.Indexes_front(self)

    def back(self):
        r"""back(Indexes self) -> std::vector< size_t >::value_type const &"""
        return _geo.Indexes_back(self)

    def assign(self, n, x):
        r"""assign(Indexes self, std::vector< size_t >::size_type n, std::vector< size_t >::value_type const & x)"""
        return _geo.Indexes_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(Indexes self, std::vector< size_t >::size_type new_size)
        resize(Indexes self, std::vector< size_t >::size_type new_size, std::vector< size_t >::value_type const & x)
        """
        return _geo.Indexes_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(Indexes self, std::vector< size_t >::iterator pos, std::vector< size_t >::value_type const & x) -> std::vector< size_t >::iterator
        insert(Indexes self, std::vector< size_t >::iterator pos, std::vector< size_t >::size_type n, std::vector< size_t >::value_type const & x)
        """
        return _geo.Indexes_insert(self, *args)

    def reserve(self, n):
        r"""reserve(Indexes self, std::vector< size_t >::size_type n)"""
        return _geo.Indexes_reserve(self, n)

    def capacity(self):
        r"""capacity(Indexes self) -> std::vector< size_t >::size_type"""
        return _geo.Indexes_capacity(self)
    __swig_destroy__ = _geo.delete_Indexes

# Register Indexes in _geo:
_geo.Indexes_swigregister(Indexes)