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

"""
TColStd module, see official documentation at
https://www.opencascade.com/doc/occt-7.7.0/refman/html/package_tcolstd.html
"""

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


class 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__ = _TColStd.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def _dumps_object(klass):
    """ Overwrite default string output for any wrapped object.
    By default, __repr__ method returns something like:
    <OCC.Core.TopoDS.TopoDS_Shape; proxy of <Swig Object of type 'TopoDS_Shape *' at 0x02BB0758> >
    This is too much verbose.
    We prefer :
    <class 'gp_Pnt'>
    or
    <class 'TopoDS_Shape'>
    """
    klass_name = str(klass.__class__).split(".")[3].split("'")[0]
    repr_string = "<class '" + klass_name + "'"
# for TopoDS_Shape, we also look for the base type
    if klass_name == "TopoDS_Shape":
        if klass.IsNull():
            repr_string += ": Null>"
            return repr_string
        st = klass.ShapeType()
        types = {OCC.Core.TopAbs.TopAbs_VERTEX: "Vertex",
                 OCC.Core.TopAbs.TopAbs_SOLID: "Solid",
                 OCC.Core.TopAbs.TopAbs_EDGE: "Edge",
                 OCC.Core.TopAbs.TopAbs_FACE: "Face",
                 OCC.Core.TopAbs.TopAbs_SHELL: "Shell",
                 OCC.Core.TopAbs.TopAbs_WIRE: "Wire",
                 OCC.Core.TopAbs.TopAbs_COMPOUND: "Compound",
                 OCC.Core.TopAbs.TopAbs_COMPSOLID: "Compsolid"}
        repr_string += "; Type:%s" % types[st]        
    elif hasattr(klass, "IsNull"):
        if klass.IsNull():
            repr_string += "; Null"
    repr_string += ">"
    return repr_string


def process_exception(error, method_name, class_name):
    return _TColStd.process_exception(error, method_name, class_name)

from six import with_metaclass
import warnings
from OCC.Wrapper.wrapper_utils import Proxy, deprecated

import OCC.Core.Standard
import OCC.Core.NCollection
import OCC.Core.TCollection

from enum import IntEnum
from OCC.Core.Exception import *




def Handle_TColStd_HPackedMapOfInteger_Create():
    return _TColStd.Handle_TColStd_HPackedMapOfInteger_Create()

def Handle_TColStd_HPackedMapOfInteger_DownCast(t):
    return _TColStd.Handle_TColStd_HPackedMapOfInteger_DownCast(t)

def Handle_TColStd_HPackedMapOfInteger_IsNull(t):
    return _TColStd.Handle_TColStd_HPackedMapOfInteger_IsNull(t)

def Handle_TColStd_HArray1OfAsciiString_Create():
    return _TColStd.Handle_TColStd_HArray1OfAsciiString_Create()

def Handle_TColStd_HArray1OfAsciiString_DownCast(t):
    return _TColStd.Handle_TColStd_HArray1OfAsciiString_DownCast(t)

def Handle_TColStd_HArray1OfAsciiString_IsNull(t):
    return _TColStd.Handle_TColStd_HArray1OfAsciiString_IsNull(t)

def Handle_TColStd_HArray1OfByte_Create():
    return _TColStd.Handle_TColStd_HArray1OfByte_Create()

def Handle_TColStd_HArray1OfByte_DownCast(t):
    return _TColStd.Handle_TColStd_HArray1OfByte_DownCast(t)

def Handle_TColStd_HArray1OfByte_IsNull(t):
    return _TColStd.Handle_TColStd_HArray1OfByte_IsNull(t)

def Handle_TColStd_HArray1OfInteger_Create():
    return _TColStd.Handle_TColStd_HArray1OfInteger_Create()

def Handle_TColStd_HArray1OfInteger_DownCast(t):
    return _TColStd.Handle_TColStd_HArray1OfInteger_DownCast(t)

def Handle_TColStd_HArray1OfInteger_IsNull(t):
    return _TColStd.Handle_TColStd_HArray1OfInteger_IsNull(t)

def Handle_TColStd_HArray1OfBoolean_Create():
    return _TColStd.Handle_TColStd_HArray1OfBoolean_Create()

def Handle_TColStd_HArray1OfBoolean_DownCast(t):
    return _TColStd.Handle_TColStd_HArray1OfBoolean_DownCast(t)

def Handle_TColStd_HArray1OfBoolean_IsNull(t):
    return _TColStd.Handle_TColStd_HArray1OfBoolean_IsNull(t)

def Handle_TColStd_HArray1OfListOfInteger_Create():
    return _TColStd.Handle_TColStd_HArray1OfListOfInteger_Create()

def Handle_TColStd_HArray1OfListOfInteger_DownCast(t):
    return _TColStd.Handle_TColStd_HArray1OfListOfInteger_DownCast(t)

def Handle_TColStd_HArray1OfListOfInteger_IsNull(t):
    return _TColStd.Handle_TColStd_HArray1OfListOfInteger_IsNull(t)

def Handle_TColStd_HArray1OfTransient_Create():
    return _TColStd.Handle_TColStd_HArray1OfTransient_Create()

def Handle_TColStd_HArray1OfTransient_DownCast(t):
    return _TColStd.Handle_TColStd_HArray1OfTransient_DownCast(t)

def Handle_TColStd_HArray1OfTransient_IsNull(t):
    return _TColStd.Handle_TColStd_HArray1OfTransient_IsNull(t)

def Handle_TColStd_HArray1OfCharacter_Create():
    return _TColStd.Handle_TColStd_HArray1OfCharacter_Create()

def Handle_TColStd_HArray1OfCharacter_DownCast(t):
    return _TColStd.Handle_TColStd_HArray1OfCharacter_DownCast(t)

def Handle_TColStd_HArray1OfCharacter_IsNull(t):
    return _TColStd.Handle_TColStd_HArray1OfCharacter_IsNull(t)

def Handle_TColStd_HArray1OfExtendedString_Create():
    return _TColStd.Handle_TColStd_HArray1OfExtendedString_Create()

def Handle_TColStd_HArray1OfExtendedString_DownCast(t):
    return _TColStd.Handle_TColStd_HArray1OfExtendedString_DownCast(t)

def Handle_TColStd_HArray1OfExtendedString_IsNull(t):
    return _TColStd.Handle_TColStd_HArray1OfExtendedString_IsNull(t)

def Handle_TColStd_HArray1OfReal_Create():
    return _TColStd.Handle_TColStd_HArray1OfReal_Create()

def Handle_TColStd_HArray1OfReal_DownCast(t):
    return _TColStd.Handle_TColStd_HArray1OfReal_DownCast(t)

def Handle_TColStd_HArray1OfReal_IsNull(t):
    return _TColStd.Handle_TColStd_HArray1OfReal_IsNull(t)

def Handle_TColStd_HArray2OfInteger_Create():
    return _TColStd.Handle_TColStd_HArray2OfInteger_Create()

def Handle_TColStd_HArray2OfInteger_DownCast(t):
    return _TColStd.Handle_TColStd_HArray2OfInteger_DownCast(t)

def Handle_TColStd_HArray2OfInteger_IsNull(t):
    return _TColStd.Handle_TColStd_HArray2OfInteger_IsNull(t)

def Handle_TColStd_HArray2OfTransient_Create():
    return _TColStd.Handle_TColStd_HArray2OfTransient_Create()

def Handle_TColStd_HArray2OfTransient_DownCast(t):
    return _TColStd.Handle_TColStd_HArray2OfTransient_DownCast(t)

def Handle_TColStd_HArray2OfTransient_IsNull(t):
    return _TColStd.Handle_TColStd_HArray2OfTransient_IsNull(t)

def Handle_TColStd_HArray2OfBoolean_Create():
    return _TColStd.Handle_TColStd_HArray2OfBoolean_Create()

def Handle_TColStd_HArray2OfBoolean_DownCast(t):
    return _TColStd.Handle_TColStd_HArray2OfBoolean_DownCast(t)

def Handle_TColStd_HArray2OfBoolean_IsNull(t):
    return _TColStd.Handle_TColStd_HArray2OfBoolean_IsNull(t)

def Handle_TColStd_HArray2OfReal_Create():
    return _TColStd.Handle_TColStd_HArray2OfReal_Create()

def Handle_TColStd_HArray2OfReal_DownCast(t):
    return _TColStd.Handle_TColStd_HArray2OfReal_DownCast(t)

def Handle_TColStd_HArray2OfReal_IsNull(t):
    return _TColStd.Handle_TColStd_HArray2OfReal_IsNull(t)

def Handle_TColStd_HArray2OfCharacter_Create():
    return _TColStd.Handle_TColStd_HArray2OfCharacter_Create()

def Handle_TColStd_HArray2OfCharacter_DownCast(t):
    return _TColStd.Handle_TColStd_HArray2OfCharacter_DownCast(t)

def Handle_TColStd_HArray2OfCharacter_IsNull(t):
    return _TColStd.Handle_TColStd_HArray2OfCharacter_IsNull(t)

def Handle_TColStd_HSequenceOfInteger_Create():
    return _TColStd.Handle_TColStd_HSequenceOfInteger_Create()

def Handle_TColStd_HSequenceOfInteger_DownCast(t):
    return _TColStd.Handle_TColStd_HSequenceOfInteger_DownCast(t)

def Handle_TColStd_HSequenceOfInteger_IsNull(t):
    return _TColStd.Handle_TColStd_HSequenceOfInteger_IsNull(t)

def Handle_TColStd_HSequenceOfExtendedString_Create():
    return _TColStd.Handle_TColStd_HSequenceOfExtendedString_Create()

def Handle_TColStd_HSequenceOfExtendedString_DownCast(t):
    return _TColStd.Handle_TColStd_HSequenceOfExtendedString_DownCast(t)

def Handle_TColStd_HSequenceOfExtendedString_IsNull(t):
    return _TColStd.Handle_TColStd_HSequenceOfExtendedString_IsNull(t)

def Handle_TColStd_HSequenceOfTransient_Create():
    return _TColStd.Handle_TColStd_HSequenceOfTransient_Create()

def Handle_TColStd_HSequenceOfTransient_DownCast(t):
    return _TColStd.Handle_TColStd_HSequenceOfTransient_DownCast(t)

def Handle_TColStd_HSequenceOfTransient_IsNull(t):
    return _TColStd.Handle_TColStd_HSequenceOfTransient_IsNull(t)

def Handle_TColStd_HSequenceOfHAsciiString_Create():
    return _TColStd.Handle_TColStd_HSequenceOfHAsciiString_Create()

def Handle_TColStd_HSequenceOfHAsciiString_DownCast(t):
    return _TColStd.Handle_TColStd_HSequenceOfHAsciiString_DownCast(t)

def Handle_TColStd_HSequenceOfHAsciiString_IsNull(t):
    return _TColStd.Handle_TColStd_HSequenceOfHAsciiString_IsNull(t)

def Handle_TColStd_HSequenceOfHExtendedString_Create():
    return _TColStd.Handle_TColStd_HSequenceOfHExtendedString_Create()

def Handle_TColStd_HSequenceOfHExtendedString_DownCast(t):
    return _TColStd.Handle_TColStd_HSequenceOfHExtendedString_DownCast(t)

def Handle_TColStd_HSequenceOfHExtendedString_IsNull(t):
    return _TColStd.Handle_TColStd_HSequenceOfHExtendedString_IsNull(t)

def Handle_TColStd_HSequenceOfReal_Create():
    return _TColStd.Handle_TColStd_HSequenceOfReal_Create()

def Handle_TColStd_HSequenceOfReal_DownCast(t):
    return _TColStd.Handle_TColStd_HSequenceOfReal_DownCast(t)

def Handle_TColStd_HSequenceOfReal_IsNull(t):
    return _TColStd.Handle_TColStd_HSequenceOfReal_IsNull(t)

def Handle_TColStd_HSequenceOfAsciiString_Create():
    return _TColStd.Handle_TColStd_HSequenceOfAsciiString_Create()

def Handle_TColStd_HSequenceOfAsciiString_DownCast(t):
    return _TColStd.Handle_TColStd_HSequenceOfAsciiString_DownCast(t)

def Handle_TColStd_HSequenceOfAsciiString_IsNull(t):
    return _TColStd.Handle_TColStd_HSequenceOfAsciiString_IsNull(t)
class TColStd_Array1OfAsciiString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_Array1OfAsciiString_begin(self)

    def end(self):
        return _TColStd.TColStd_Array1OfAsciiString_end(self)

    def cbegin(self):
        return _TColStd.TColStd_Array1OfAsciiString_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_Array1OfAsciiString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfAsciiString_swiginit(self, _TColStd.new_TColStd_Array1OfAsciiString(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array1OfAsciiString_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array1OfAsciiString_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array1OfAsciiString_Length(self)

    def IsEmpty(self):
        return _TColStd.TColStd_Array1OfAsciiString_IsEmpty(self)

    def Lower(self):
        return _TColStd.TColStd_Array1OfAsciiString_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_Array1OfAsciiString_Upper(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array1OfAsciiString_IsDeletable(self)

    def IsAllocated(self):
        return _TColStd.TColStd_Array1OfAsciiString_IsAllocated(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array1OfAsciiString_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array1OfAsciiString_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array1OfAsciiString_Set(self, *args)

    def First(self):
        return _TColStd.TColStd_Array1OfAsciiString_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_Array1OfAsciiString_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_Array1OfAsciiString_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_Array1OfAsciiString_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_Array1OfAsciiString_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_Array1OfAsciiString_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_Array1OfAsciiString___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_Array1OfAsciiString_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        return _TColStd.TColStd_Array1OfAsciiString_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfAsciiString

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register TColStd_Array1OfAsciiString in _TColStd:
_TColStd.TColStd_Array1OfAsciiString_swigregister(TColStd_Array1OfAsciiString)
class TColStd_Array1OfBoolean(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_Array1OfBoolean_begin(self)

    def end(self):
        return _TColStd.TColStd_Array1OfBoolean_end(self)

    def cbegin(self):
        return _TColStd.TColStd_Array1OfBoolean_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_Array1OfBoolean_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfBoolean_swiginit(self, _TColStd.new_TColStd_Array1OfBoolean(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array1OfBoolean_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array1OfBoolean_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array1OfBoolean_Length(self)

    def IsEmpty(self):
        return _TColStd.TColStd_Array1OfBoolean_IsEmpty(self)

    def Lower(self):
        return _TColStd.TColStd_Array1OfBoolean_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_Array1OfBoolean_Upper(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array1OfBoolean_IsDeletable(self)

    def IsAllocated(self):
        return _TColStd.TColStd_Array1OfBoolean_IsAllocated(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array1OfBoolean_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array1OfBoolean_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array1OfBoolean_Set(self, *args)

    def First(self):
        return _TColStd.TColStd_Array1OfBoolean_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_Array1OfBoolean_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_Array1OfBoolean_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_Array1OfBoolean_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_Array1OfBoolean_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_Array1OfBoolean_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_Array1OfBoolean___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_Array1OfBoolean_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        return _TColStd.TColStd_Array1OfBoolean_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfBoolean

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register TColStd_Array1OfBoolean in _TColStd:
_TColStd.TColStd_Array1OfBoolean_swigregister(TColStd_Array1OfBoolean)
class TColStd_Array1OfByte(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_Array1OfByte_begin(self)

    def end(self):
        return _TColStd.TColStd_Array1OfByte_end(self)

    def cbegin(self):
        return _TColStd.TColStd_Array1OfByte_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_Array1OfByte_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfByte_swiginit(self, _TColStd.new_TColStd_Array1OfByte(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array1OfByte_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array1OfByte_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array1OfByte_Length(self)

    def IsEmpty(self):
        return _TColStd.TColStd_Array1OfByte_IsEmpty(self)

    def Lower(self):
        return _TColStd.TColStd_Array1OfByte_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_Array1OfByte_Upper(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array1OfByte_IsDeletable(self)

    def IsAllocated(self):
        return _TColStd.TColStd_Array1OfByte_IsAllocated(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array1OfByte_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array1OfByte_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array1OfByte_Set(self, *args)

    def First(self):
        return _TColStd.TColStd_Array1OfByte_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_Array1OfByte_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_Array1OfByte_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_Array1OfByte_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_Array1OfByte_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_Array1OfByte_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_Array1OfByte___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_Array1OfByte_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        return _TColStd.TColStd_Array1OfByte_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfByte

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register TColStd_Array1OfByte in _TColStd:
_TColStd.TColStd_Array1OfByte_swigregister(TColStd_Array1OfByte)
class TColStd_Array1OfCharacter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_Array1OfCharacter_begin(self)

    def end(self):
        return _TColStd.TColStd_Array1OfCharacter_end(self)

    def cbegin(self):
        return _TColStd.TColStd_Array1OfCharacter_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_Array1OfCharacter_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfCharacter_swiginit(self, _TColStd.new_TColStd_Array1OfCharacter(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array1OfCharacter_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array1OfCharacter_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array1OfCharacter_Length(self)

    def IsEmpty(self):
        return _TColStd.TColStd_Array1OfCharacter_IsEmpty(self)

    def Lower(self):
        return _TColStd.TColStd_Array1OfCharacter_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_Array1OfCharacter_Upper(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array1OfCharacter_IsDeletable(self)

    def IsAllocated(self):
        return _TColStd.TColStd_Array1OfCharacter_IsAllocated(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array1OfCharacter_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array1OfCharacter_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array1OfCharacter_Set(self, *args)

    def First(self):
        return _TColStd.TColStd_Array1OfCharacter_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_Array1OfCharacter_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_Array1OfCharacter_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_Array1OfCharacter_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_Array1OfCharacter_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_Array1OfCharacter_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_Array1OfCharacter___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_Array1OfCharacter_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        return _TColStd.TColStd_Array1OfCharacter_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfCharacter

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register TColStd_Array1OfCharacter in _TColStd:
_TColStd.TColStd_Array1OfCharacter_swigregister(TColStd_Array1OfCharacter)
class TColStd_Array1OfExtendedString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_Array1OfExtendedString_begin(self)

    def end(self):
        return _TColStd.TColStd_Array1OfExtendedString_end(self)

    def cbegin(self):
        return _TColStd.TColStd_Array1OfExtendedString_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_Array1OfExtendedString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfExtendedString_swiginit(self, _TColStd.new_TColStd_Array1OfExtendedString(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array1OfExtendedString_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array1OfExtendedString_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array1OfExtendedString_Length(self)

    def IsEmpty(self):
        return _TColStd.TColStd_Array1OfExtendedString_IsEmpty(self)

    def Lower(self):
        return _TColStd.TColStd_Array1OfExtendedString_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_Array1OfExtendedString_Upper(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array1OfExtendedString_IsDeletable(self)

    def IsAllocated(self):
        return _TColStd.TColStd_Array1OfExtendedString_IsAllocated(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array1OfExtendedString_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array1OfExtendedString_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array1OfExtendedString_Set(self, *args)

    def First(self):
        return _TColStd.TColStd_Array1OfExtendedString_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_Array1OfExtendedString_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_Array1OfExtendedString_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_Array1OfExtendedString_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_Array1OfExtendedString_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_Array1OfExtendedString_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_Array1OfExtendedString___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_Array1OfExtendedString_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        return _TColStd.TColStd_Array1OfExtendedString_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfExtendedString

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register TColStd_Array1OfExtendedString in _TColStd:
_TColStd.TColStd_Array1OfExtendedString_swigregister(TColStd_Array1OfExtendedString)
class TColStd_Array1OfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_Array1OfInteger_begin(self)

    def end(self):
        return _TColStd.TColStd_Array1OfInteger_end(self)

    def cbegin(self):
        return _TColStd.TColStd_Array1OfInteger_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_Array1OfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfInteger_swiginit(self, _TColStd.new_TColStd_Array1OfInteger(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array1OfInteger_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array1OfInteger_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array1OfInteger_Length(self)

    def IsEmpty(self):
        return _TColStd.TColStd_Array1OfInteger_IsEmpty(self)

    def Lower(self):
        return _TColStd.TColStd_Array1OfInteger_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_Array1OfInteger_Upper(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array1OfInteger_IsDeletable(self)

    def IsAllocated(self):
        return _TColStd.TColStd_Array1OfInteger_IsAllocated(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array1OfInteger_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array1OfInteger_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array1OfInteger_Set(self, *args)

    def First(self):
        return _TColStd.TColStd_Array1OfInteger_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_Array1OfInteger_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_Array1OfInteger_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_Array1OfInteger_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_Array1OfInteger_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_Array1OfInteger_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_Array1OfInteger___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_Array1OfInteger_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        return _TColStd.TColStd_Array1OfInteger_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfInteger

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register TColStd_Array1OfInteger in _TColStd:
_TColStd.TColStd_Array1OfInteger_swigregister(TColStd_Array1OfInteger)
class TColStd_Array1OfListOfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_Array1OfListOfInteger_begin(self)

    def end(self):
        return _TColStd.TColStd_Array1OfListOfInteger_end(self)

    def cbegin(self):
        return _TColStd.TColStd_Array1OfListOfInteger_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_Array1OfListOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfListOfInteger_swiginit(self, _TColStd.new_TColStd_Array1OfListOfInteger(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array1OfListOfInteger_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array1OfListOfInteger_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array1OfListOfInteger_Length(self)

    def IsEmpty(self):
        return _TColStd.TColStd_Array1OfListOfInteger_IsEmpty(self)

    def Lower(self):
        return _TColStd.TColStd_Array1OfListOfInteger_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_Array1OfListOfInteger_Upper(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array1OfListOfInteger_IsDeletable(self)

    def IsAllocated(self):
        return _TColStd.TColStd_Array1OfListOfInteger_IsAllocated(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array1OfListOfInteger_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array1OfListOfInteger_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array1OfListOfInteger_Set(self, *args)

    def First(self):
        return _TColStd.TColStd_Array1OfListOfInteger_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_Array1OfListOfInteger_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_Array1OfListOfInteger_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_Array1OfListOfInteger_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_Array1OfListOfInteger_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_Array1OfListOfInteger_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_Array1OfListOfInteger___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_Array1OfListOfInteger_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        return _TColStd.TColStd_Array1OfListOfInteger_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfListOfInteger

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register TColStd_Array1OfListOfInteger in _TColStd:
_TColStd.TColStd_Array1OfListOfInteger_swigregister(TColStd_Array1OfListOfInteger)
class TColStd_Array1OfReal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_Array1OfReal_begin(self)

    def end(self):
        return _TColStd.TColStd_Array1OfReal_end(self)

    def cbegin(self):
        return _TColStd.TColStd_Array1OfReal_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_Array1OfReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfReal_swiginit(self, _TColStd.new_TColStd_Array1OfReal(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array1OfReal_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array1OfReal_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array1OfReal_Length(self)

    def IsEmpty(self):
        return _TColStd.TColStd_Array1OfReal_IsEmpty(self)

    def Lower(self):
        return _TColStd.TColStd_Array1OfReal_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_Array1OfReal_Upper(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array1OfReal_IsDeletable(self)

    def IsAllocated(self):
        return _TColStd.TColStd_Array1OfReal_IsAllocated(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array1OfReal_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array1OfReal_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array1OfReal_Set(self, *args)

    def First(self):
        return _TColStd.TColStd_Array1OfReal_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_Array1OfReal_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_Array1OfReal_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_Array1OfReal_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_Array1OfReal_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_Array1OfReal_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_Array1OfReal___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_Array1OfReal_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        return _TColStd.TColStd_Array1OfReal_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfReal

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register TColStd_Array1OfReal in _TColStd:
_TColStd.TColStd_Array1OfReal_swigregister(TColStd_Array1OfReal)
class TColStd_Array1OfTransient(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_Array1OfTransient_begin(self)

    def end(self):
        return _TColStd.TColStd_Array1OfTransient_end(self)

    def cbegin(self):
        return _TColStd.TColStd_Array1OfTransient_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_Array1OfTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_Array1OfTransient_swiginit(self, _TColStd.new_TColStd_Array1OfTransient(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array1OfTransient_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array1OfTransient_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array1OfTransient_Length(self)

    def IsEmpty(self):
        return _TColStd.TColStd_Array1OfTransient_IsEmpty(self)

    def Lower(self):
        return _TColStd.TColStd_Array1OfTransient_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_Array1OfTransient_Upper(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array1OfTransient_IsDeletable(self)

    def IsAllocated(self):
        return _TColStd.TColStd_Array1OfTransient_IsAllocated(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array1OfTransient_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array1OfTransient_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array1OfTransient_Set(self, *args)

    def First(self):
        return _TColStd.TColStd_Array1OfTransient_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_Array1OfTransient_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_Array1OfTransient_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_Array1OfTransient_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_Array1OfTransient_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_Array1OfTransient_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_Array1OfTransient___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_Array1OfTransient_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        return _TColStd.TColStd_Array1OfTransient_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array1OfTransient

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register TColStd_Array1OfTransient in _TColStd:
_TColStd.TColStd_Array1OfTransient_swigregister(TColStd_Array1OfTransient)
class TColStd_Array2OfBoolean(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _TColStd.TColStd_Array2OfBoolean_swiginit(self, _TColStd.new_TColStd_Array2OfBoolean(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array2OfBoolean_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array2OfBoolean_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array2OfBoolean_Length(self)

    def NbRows(self):
        return _TColStd.TColStd_Array2OfBoolean_NbRows(self)

    def NbColumns(self):
        return _TColStd.TColStd_Array2OfBoolean_NbColumns(self)

    def RowLength(self):
        return _TColStd.TColStd_Array2OfBoolean_RowLength(self)

    def ColLength(self):
        return _TColStd.TColStd_Array2OfBoolean_ColLength(self)

    def LowerRow(self):
        return _TColStd.TColStd_Array2OfBoolean_LowerRow(self)

    def UpperRow(self):
        return _TColStd.TColStd_Array2OfBoolean_UpperRow(self)

    def LowerCol(self):
        return _TColStd.TColStd_Array2OfBoolean_LowerCol(self)

    def UpperCol(self):
        return _TColStd.TColStd_Array2OfBoolean_UpperCol(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array2OfBoolean_IsDeletable(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array2OfBoolean_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array2OfBoolean_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array2OfBoolean_Set(self, *args)

    def Value(self, theRow, theCol):
        return _TColStd.TColStd_Array2OfBoolean_Value(self, theRow, theCol)

    def ChangeValue(self, theRow, theCol):
        return _TColStd.TColStd_Array2OfBoolean_ChangeValue(self, theRow, theCol)

    def __call__(self, *args):
        return _TColStd.TColStd_Array2OfBoolean___call__(self, *args)

    def SetValue(self, theRow, theCol, theItem):
        return _TColStd.TColStd_Array2OfBoolean_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData):
        return _TColStd.TColStd_Array2OfBoolean_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array2OfBoolean

# Register TColStd_Array2OfBoolean in _TColStd:
_TColStd.TColStd_Array2OfBoolean_swigregister(TColStd_Array2OfBoolean)
class TColStd_Array2OfCharacter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _TColStd.TColStd_Array2OfCharacter_swiginit(self, _TColStd.new_TColStd_Array2OfCharacter(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array2OfCharacter_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array2OfCharacter_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array2OfCharacter_Length(self)

    def NbRows(self):
        return _TColStd.TColStd_Array2OfCharacter_NbRows(self)

    def NbColumns(self):
        return _TColStd.TColStd_Array2OfCharacter_NbColumns(self)

    def RowLength(self):
        return _TColStd.TColStd_Array2OfCharacter_RowLength(self)

    def ColLength(self):
        return _TColStd.TColStd_Array2OfCharacter_ColLength(self)

    def LowerRow(self):
        return _TColStd.TColStd_Array2OfCharacter_LowerRow(self)

    def UpperRow(self):
        return _TColStd.TColStd_Array2OfCharacter_UpperRow(self)

    def LowerCol(self):
        return _TColStd.TColStd_Array2OfCharacter_LowerCol(self)

    def UpperCol(self):
        return _TColStd.TColStd_Array2OfCharacter_UpperCol(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array2OfCharacter_IsDeletable(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array2OfCharacter_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array2OfCharacter_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array2OfCharacter_Set(self, *args)

    def Value(self, theRow, theCol):
        return _TColStd.TColStd_Array2OfCharacter_Value(self, theRow, theCol)

    def ChangeValue(self, theRow, theCol):
        return _TColStd.TColStd_Array2OfCharacter_ChangeValue(self, theRow, theCol)

    def __call__(self, *args):
        return _TColStd.TColStd_Array2OfCharacter___call__(self, *args)

    def SetValue(self, theRow, theCol, theItem):
        return _TColStd.TColStd_Array2OfCharacter_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData):
        return _TColStd.TColStd_Array2OfCharacter_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array2OfCharacter

# Register TColStd_Array2OfCharacter in _TColStd:
_TColStd.TColStd_Array2OfCharacter_swigregister(TColStd_Array2OfCharacter)
class TColStd_Array2OfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _TColStd.TColStd_Array2OfInteger_swiginit(self, _TColStd.new_TColStd_Array2OfInteger(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array2OfInteger_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array2OfInteger_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array2OfInteger_Length(self)

    def NbRows(self):
        return _TColStd.TColStd_Array2OfInteger_NbRows(self)

    def NbColumns(self):
        return _TColStd.TColStd_Array2OfInteger_NbColumns(self)

    def RowLength(self):
        return _TColStd.TColStd_Array2OfInteger_RowLength(self)

    def ColLength(self):
        return _TColStd.TColStd_Array2OfInteger_ColLength(self)

    def LowerRow(self):
        return _TColStd.TColStd_Array2OfInteger_LowerRow(self)

    def UpperRow(self):
        return _TColStd.TColStd_Array2OfInteger_UpperRow(self)

    def LowerCol(self):
        return _TColStd.TColStd_Array2OfInteger_LowerCol(self)

    def UpperCol(self):
        return _TColStd.TColStd_Array2OfInteger_UpperCol(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array2OfInteger_IsDeletable(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array2OfInteger_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array2OfInteger_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array2OfInteger_Set(self, *args)

    def Value(self, theRow, theCol):
        return _TColStd.TColStd_Array2OfInteger_Value(self, theRow, theCol)

    def ChangeValue(self, theRow, theCol):
        return _TColStd.TColStd_Array2OfInteger_ChangeValue(self, theRow, theCol)

    def __call__(self, *args):
        return _TColStd.TColStd_Array2OfInteger___call__(self, *args)

    def SetValue(self, theRow, theCol, theItem):
        return _TColStd.TColStd_Array2OfInteger_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData):
        return _TColStd.TColStd_Array2OfInteger_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array2OfInteger

# Register TColStd_Array2OfInteger in _TColStd:
_TColStd.TColStd_Array2OfInteger_swigregister(TColStd_Array2OfInteger)
class TColStd_Array2OfReal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _TColStd.TColStd_Array2OfReal_swiginit(self, _TColStd.new_TColStd_Array2OfReal(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array2OfReal_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array2OfReal_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array2OfReal_Length(self)

    def NbRows(self):
        return _TColStd.TColStd_Array2OfReal_NbRows(self)

    def NbColumns(self):
        return _TColStd.TColStd_Array2OfReal_NbColumns(self)

    def RowLength(self):
        return _TColStd.TColStd_Array2OfReal_RowLength(self)

    def ColLength(self):
        return _TColStd.TColStd_Array2OfReal_ColLength(self)

    def LowerRow(self):
        return _TColStd.TColStd_Array2OfReal_LowerRow(self)

    def UpperRow(self):
        return _TColStd.TColStd_Array2OfReal_UpperRow(self)

    def LowerCol(self):
        return _TColStd.TColStd_Array2OfReal_LowerCol(self)

    def UpperCol(self):
        return _TColStd.TColStd_Array2OfReal_UpperCol(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array2OfReal_IsDeletable(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array2OfReal_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array2OfReal_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array2OfReal_Set(self, *args)

    def Value(self, theRow, theCol):
        return _TColStd.TColStd_Array2OfReal_Value(self, theRow, theCol)

    def ChangeValue(self, theRow, theCol):
        return _TColStd.TColStd_Array2OfReal_ChangeValue(self, theRow, theCol)

    def __call__(self, *args):
        return _TColStd.TColStd_Array2OfReal___call__(self, *args)

    def SetValue(self, theRow, theCol, theItem):
        return _TColStd.TColStd_Array2OfReal_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData):
        return _TColStd.TColStd_Array2OfReal_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array2OfReal

# Register TColStd_Array2OfReal in _TColStd:
_TColStd.TColStd_Array2OfReal_swigregister(TColStd_Array2OfReal)
class TColStd_Array2OfTransient(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _TColStd.TColStd_Array2OfTransient_swiginit(self, _TColStd.new_TColStd_Array2OfTransient(*args))

    def Init(self, theValue):
        return _TColStd.TColStd_Array2OfTransient_Init(self, theValue)

    def Size(self):
        return _TColStd.TColStd_Array2OfTransient_Size(self)

    def Length(self):
        return _TColStd.TColStd_Array2OfTransient_Length(self)

    def NbRows(self):
        return _TColStd.TColStd_Array2OfTransient_NbRows(self)

    def NbColumns(self):
        return _TColStd.TColStd_Array2OfTransient_NbColumns(self)

    def RowLength(self):
        return _TColStd.TColStd_Array2OfTransient_RowLength(self)

    def ColLength(self):
        return _TColStd.TColStd_Array2OfTransient_ColLength(self)

    def LowerRow(self):
        return _TColStd.TColStd_Array2OfTransient_LowerRow(self)

    def UpperRow(self):
        return _TColStd.TColStd_Array2OfTransient_UpperRow(self)

    def LowerCol(self):
        return _TColStd.TColStd_Array2OfTransient_LowerCol(self)

    def UpperCol(self):
        return _TColStd.TColStd_Array2OfTransient_UpperCol(self)

    def IsDeletable(self):
        return _TColStd.TColStd_Array2OfTransient_IsDeletable(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_Array2OfTransient_Assign(self, theOther)

    def Move(self, theOther):
        return _TColStd.TColStd_Array2OfTransient_Move(self, theOther)

    def Set(self, *args):
        return _TColStd.TColStd_Array2OfTransient_Set(self, *args)

    def Value(self, theRow, theCol):
        return _TColStd.TColStd_Array2OfTransient_Value(self, theRow, theCol)

    def ChangeValue(self, theRow, theCol):
        return _TColStd.TColStd_Array2OfTransient_ChangeValue(self, theRow, theCol)

    def __call__(self, *args):
        return _TColStd.TColStd_Array2OfTransient___call__(self, *args)

    def SetValue(self, theRow, theCol, theItem):
        return _TColStd.TColStd_Array2OfTransient_SetValue(self, theRow, theCol, theItem)

    def Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData):
        return _TColStd.TColStd_Array2OfTransient_Resize(self, theRowLower, theRowUpper, theColLower, theColUpper, theToCopyData)
    __swig_destroy__ = _TColStd.delete_TColStd_Array2OfTransient

# Register TColStd_Array2OfTransient in _TColStd:
_TColStd.TColStd_Array2OfTransient_swigregister(TColStd_Array2OfTransient)
class TColStd_DataMapOfAsciiStringInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_begin(self)

    def end(self):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_end(self)

    def cbegin(self):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfAsciiStringInteger_swiginit(self, _TColStd.new_TColStd_DataMapOfAsciiStringInteger(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_UnBind(self, theKey)

    def Seek(self, theKey):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Seek(self, theKey)

    def Find(self, *args):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger___call__(self, *args)

    def Clear(self, *args):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfAsciiStringInteger

    def Size(self):
        return _TColStd.TColStd_DataMapOfAsciiStringInteger_Size(self)

# Register TColStd_DataMapOfAsciiStringInteger in _TColStd:
_TColStd.TColStd_DataMapOfAsciiStringInteger_swigregister(TColStd_DataMapOfAsciiStringInteger)
class TColStd_DataMapOfIntegerInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_DataMapOfIntegerInteger_begin(self)

    def end(self):
        return _TColStd.TColStd_DataMapOfIntegerInteger_end(self)

    def cbegin(self):
        return _TColStd.TColStd_DataMapOfIntegerInteger_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_DataMapOfIntegerInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfIntegerInteger_swiginit(self, _TColStd.new_TColStd_DataMapOfIntegerInteger(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerInteger_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_DataMapOfIntegerInteger_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfIntegerInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfIntegerInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerInteger_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerInteger_UnBind(self, theKey)

    def Seek(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerInteger_Seek(self, theKey)

    def Find(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerInteger_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerInteger_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerInteger___call__(self, *args)

    def Clear(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfIntegerInteger

    def Size(self):
        return _TColStd.TColStd_DataMapOfIntegerInteger_Size(self)

    def Keys(self):
        return _TColStd.TColStd_DataMapOfIntegerInteger_Keys(self)

# Register TColStd_DataMapOfIntegerInteger in _TColStd:
_TColStd.TColStd_DataMapOfIntegerInteger_swigregister(TColStd_DataMapOfIntegerInteger)
class TColStd_DataMapOfIntegerListOfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_begin(self)

    def end(self):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_end(self)

    def cbegin(self):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfIntegerListOfInteger_swiginit(self, _TColStd.new_TColStd_DataMapOfIntegerListOfInteger(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_UnBind(self, theKey)

    def Seek(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Seek(self, theKey)

    def Find(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger___call__(self, *args)

    def Clear(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfIntegerListOfInteger

    def Size(self):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Size(self)

    def Keys(self):
        return _TColStd.TColStd_DataMapOfIntegerListOfInteger_Keys(self)

# Register TColStd_DataMapOfIntegerListOfInteger in _TColStd:
_TColStd.TColStd_DataMapOfIntegerListOfInteger_swigregister(TColStd_DataMapOfIntegerListOfInteger)
class TColStd_DataMapOfIntegerReal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_DataMapOfIntegerReal_begin(self)

    def end(self):
        return _TColStd.TColStd_DataMapOfIntegerReal_end(self)

    def cbegin(self):
        return _TColStd.TColStd_DataMapOfIntegerReal_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_DataMapOfIntegerReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfIntegerReal_swiginit(self, _TColStd.new_TColStd_DataMapOfIntegerReal(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerReal_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerReal_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerReal_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_DataMapOfIntegerReal_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfIntegerReal_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfIntegerReal_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerReal_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerReal_UnBind(self, theKey)

    def Seek(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerReal_Seek(self, theKey)

    def Find(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerReal_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerReal_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerReal_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerReal___call__(self, *args)

    def Clear(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerReal_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfIntegerReal

    def Size(self):
        return _TColStd.TColStd_DataMapOfIntegerReal_Size(self)

    def Keys(self):
        return _TColStd.TColStd_DataMapOfIntegerReal_Keys(self)

# Register TColStd_DataMapOfIntegerReal in _TColStd:
_TColStd.TColStd_DataMapOfIntegerReal_swigregister(TColStd_DataMapOfIntegerReal)
class TColStd_DataMapOfIntegerTransient(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_DataMapOfIntegerTransient_begin(self)

    def end(self):
        return _TColStd.TColStd_DataMapOfIntegerTransient_end(self)

    def cbegin(self):
        return _TColStd.TColStd_DataMapOfIntegerTransient_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_DataMapOfIntegerTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfIntegerTransient_swiginit(self, _TColStd.new_TColStd_DataMapOfIntegerTransient(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerTransient_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerTransient_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_DataMapOfIntegerTransient_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_DataMapOfIntegerTransient_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfIntegerTransient_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfIntegerTransient_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerTransient_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerTransient_UnBind(self, theKey)

    def Seek(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerTransient_Seek(self, theKey)

    def Find(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerTransient_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerTransient_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _TColStd.TColStd_DataMapOfIntegerTransient_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerTransient___call__(self, *args)

    def Clear(self, *args):
        return _TColStd.TColStd_DataMapOfIntegerTransient_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfIntegerTransient

    def Size(self):
        return _TColStd.TColStd_DataMapOfIntegerTransient_Size(self)

    def Keys(self):
        return _TColStd.TColStd_DataMapOfIntegerTransient_Keys(self)

# Register TColStd_DataMapOfIntegerTransient in _TColStd:
_TColStd.TColStd_DataMapOfIntegerTransient_swigregister(TColStd_DataMapOfIntegerTransient)
class TColStd_DataMapOfStringInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_DataMapOfStringInteger_begin(self)

    def end(self):
        return _TColStd.TColStd_DataMapOfStringInteger_end(self)

    def cbegin(self):
        return _TColStd.TColStd_DataMapOfStringInteger_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_DataMapOfStringInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfStringInteger_swiginit(self, _TColStd.new_TColStd_DataMapOfStringInteger(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_DataMapOfStringInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_DataMapOfStringInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_DataMapOfStringInteger_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_DataMapOfStringInteger_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfStringInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfStringInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _TColStd.TColStd_DataMapOfStringInteger_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _TColStd.TColStd_DataMapOfStringInteger_UnBind(self, theKey)

    def Seek(self, theKey):
        return _TColStd.TColStd_DataMapOfStringInteger_Seek(self, theKey)

    def Find(self, *args):
        return _TColStd.TColStd_DataMapOfStringInteger_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _TColStd.TColStd_DataMapOfStringInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _TColStd.TColStd_DataMapOfStringInteger_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _TColStd.TColStd_DataMapOfStringInteger___call__(self, *args)

    def Clear(self, *args):
        return _TColStd.TColStd_DataMapOfStringInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfStringInteger

    def Size(self):
        return _TColStd.TColStd_DataMapOfStringInteger_Size(self)

# Register TColStd_DataMapOfStringInteger in _TColStd:
_TColStd.TColStd_DataMapOfStringInteger_swigregister(TColStd_DataMapOfStringInteger)
class TColStd_DataMapOfTransientTransient(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_DataMapOfTransientTransient_begin(self)

    def end(self):
        return _TColStd.TColStd_DataMapOfTransientTransient_end(self)

    def cbegin(self):
        return _TColStd.TColStd_DataMapOfTransientTransient_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_DataMapOfTransientTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_DataMapOfTransientTransient_swiginit(self, _TColStd.new_TColStd_DataMapOfTransientTransient(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_DataMapOfTransientTransient_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_DataMapOfTransientTransient_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_DataMapOfTransientTransient_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_DataMapOfTransientTransient_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfTransientTransient_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _TColStd.TColStd_DataMapOfTransientTransient_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _TColStd.TColStd_DataMapOfTransientTransient_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _TColStd.TColStd_DataMapOfTransientTransient_UnBind(self, theKey)

    def Seek(self, theKey):
        return _TColStd.TColStd_DataMapOfTransientTransient_Seek(self, theKey)

    def Find(self, *args):
        return _TColStd.TColStd_DataMapOfTransientTransient_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _TColStd.TColStd_DataMapOfTransientTransient_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _TColStd.TColStd_DataMapOfTransientTransient_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _TColStd.TColStd_DataMapOfTransientTransient___call__(self, *args)

    def Clear(self, *args):
        return _TColStd.TColStd_DataMapOfTransientTransient_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_DataMapOfTransientTransient

    def Size(self):
        return _TColStd.TColStd_DataMapOfTransientTransient_Size(self)

# Register TColStd_DataMapOfTransientTransient in _TColStd:
_TColStd.TColStd_DataMapOfTransientTransient_swigregister(TColStd_DataMapOfTransientTransient)
class TColStd_IndexedDataMapOfStringString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_IndexedDataMapOfStringString_begin(self)

    def end(self):
        return _TColStd.TColStd_IndexedDataMapOfStringString_end(self)

    def cbegin(self):
        return _TColStd.TColStd_IndexedDataMapOfStringString_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_IndexedDataMapOfStringString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_IndexedDataMapOfStringString_swiginit(self, _TColStd.new_TColStd_IndexedDataMapOfStringString(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_IndexedDataMapOfStringString_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_IndexedDataMapOfStringString_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_IndexedDataMapOfStringString_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_IndexedDataMapOfStringString_ReSize(self, N)

    def Add(self, theKey1, theItem):
        return _TColStd.TColStd_IndexedDataMapOfStringString_Add(self, theKey1, theItem)

    def Contains(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfStringString_Contains(self, theKey1)

    def Substitute(self, theIndex, theKey1, theItem):
        return _TColStd.TColStd_IndexedDataMapOfStringString_Substitute(self, theIndex, theKey1, theItem)

    def Swap(self, theIndex1, theIndex2):
        return _TColStd.TColStd_IndexedDataMapOfStringString_Swap(self, theIndex1, theIndex2)

    def RemoveLast(self):
        return _TColStd.TColStd_IndexedDataMapOfStringString_RemoveLast(self)

    def RemoveFromIndex(self, theIndex):
        return _TColStd.TColStd_IndexedDataMapOfStringString_RemoveFromIndex(self, theIndex)

    def RemoveKey(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfStringString_RemoveKey(self, theKey1)

    def FindKey(self, theIndex):
        return _TColStd.TColStd_IndexedDataMapOfStringString_FindKey(self, theIndex)

    def FindFromIndex(self, theIndex):
        return _TColStd.TColStd_IndexedDataMapOfStringString_FindFromIndex(self, theIndex)

    def ChangeFromIndex(self, theIndex):
        return _TColStd.TColStd_IndexedDataMapOfStringString_ChangeFromIndex(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_IndexedDataMapOfStringString___call__(self, *args)

    def FindIndex(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfStringString_FindIndex(self, theKey1)

    def ChangeFromKey(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfStringString_ChangeFromKey(self, theKey1)

    def Seek(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfStringString_Seek(self, theKey1)

    def ChangeSeek(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfStringString_ChangeSeek(self, theKey1)

    def FindFromKey(self, *args):
        return _TColStd.TColStd_IndexedDataMapOfStringString_FindFromKey(self, *args)

    def Clear(self, *args):
        return _TColStd.TColStd_IndexedDataMapOfStringString_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_IndexedDataMapOfStringString

    def Size(self):
        return _TColStd.TColStd_IndexedDataMapOfStringString_Size(self)

# Register TColStd_IndexedDataMapOfStringString in _TColStd:
_TColStd.TColStd_IndexedDataMapOfStringString_swigregister(TColStd_IndexedDataMapOfStringString)
class TColStd_IndexedDataMapOfTransientTransient(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_begin(self)

    def end(self):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_end(self)

    def cbegin(self):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_IndexedDataMapOfTransientTransient_swiginit(self, _TColStd.new_TColStd_IndexedDataMapOfTransientTransient(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_ReSize(self, N)

    def Add(self, theKey1, theItem):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Add(self, theKey1, theItem)

    def Contains(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Contains(self, theKey1)

    def Substitute(self, theIndex, theKey1, theItem):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Substitute(self, theIndex, theKey1, theItem)

    def Swap(self, theIndex1, theIndex2):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Swap(self, theIndex1, theIndex2)

    def RemoveLast(self):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_RemoveLast(self)

    def RemoveFromIndex(self, theIndex):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_RemoveFromIndex(self, theIndex)

    def RemoveKey(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_RemoveKey(self, theKey1)

    def FindKey(self, theIndex):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_FindKey(self, theIndex)

    def FindFromIndex(self, theIndex):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_FindFromIndex(self, theIndex)

    def ChangeFromIndex(self, theIndex):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_ChangeFromIndex(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient___call__(self, *args)

    def FindIndex(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_FindIndex(self, theKey1)

    def ChangeFromKey(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_ChangeFromKey(self, theKey1)

    def Seek(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Seek(self, theKey1)

    def ChangeSeek(self, theKey1):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_ChangeSeek(self, theKey1)

    def FindFromKey(self, *args):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_FindFromKey(self, *args)

    def Clear(self, *args):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_IndexedDataMapOfTransientTransient

    def Size(self):
        return _TColStd.TColStd_IndexedDataMapOfTransientTransient_Size(self)

# Register TColStd_IndexedDataMapOfTransientTransient in _TColStd:
_TColStd.TColStd_IndexedDataMapOfTransientTransient_swigregister(TColStd_IndexedDataMapOfTransientTransient)
class TColStd_IndexedMapOfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def cbegin(self):
        return _TColStd.TColStd_IndexedMapOfInteger_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_IndexedMapOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_IndexedMapOfInteger_swiginit(self, _TColStd.new_TColStd_IndexedMapOfInteger(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_IndexedMapOfInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_IndexedMapOfInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_IndexedMapOfInteger_Set(self, theOther)

    def ReSize(self, theExtent):
        return _TColStd.TColStd_IndexedMapOfInteger_ReSize(self, theExtent)

    def Add(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfInteger_Add(self, theKey1)

    def Contains(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfInteger_Contains(self, theKey1)

    def Substitute(self, theIndex, theKey1):
        return _TColStd.TColStd_IndexedMapOfInteger_Substitute(self, theIndex, theKey1)

    def Swap(self, theIndex1, theIndex2):
        return _TColStd.TColStd_IndexedMapOfInteger_Swap(self, theIndex1, theIndex2)

    def RemoveLast(self):
        return _TColStd.TColStd_IndexedMapOfInteger_RemoveLast(self)

    def RemoveFromIndex(self, theIndex):
        return _TColStd.TColStd_IndexedMapOfInteger_RemoveFromIndex(self, theIndex)

    def RemoveKey(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfInteger_RemoveKey(self, theKey1)

    def FindKey(self, theIndex):
        return _TColStd.TColStd_IndexedMapOfInteger_FindKey(self, theIndex)

    def __call__(self, theIndex):
        return _TColStd.TColStd_IndexedMapOfInteger___call__(self, theIndex)

    def FindIndex(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfInteger_FindIndex(self, theKey1)

    def Clear(self, *args):
        return _TColStd.TColStd_IndexedMapOfInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_IndexedMapOfInteger

    def Size(self):
        return _TColStd.TColStd_IndexedMapOfInteger_Size(self)

# Register TColStd_IndexedMapOfInteger in _TColStd:
_TColStd.TColStd_IndexedMapOfInteger_swigregister(TColStd_IndexedMapOfInteger)
class TColStd_IndexedMapOfReal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def cbegin(self):
        return _TColStd.TColStd_IndexedMapOfReal_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_IndexedMapOfReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_IndexedMapOfReal_swiginit(self, _TColStd.new_TColStd_IndexedMapOfReal(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_IndexedMapOfReal_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_IndexedMapOfReal_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_IndexedMapOfReal_Set(self, theOther)

    def ReSize(self, theExtent):
        return _TColStd.TColStd_IndexedMapOfReal_ReSize(self, theExtent)

    def Add(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfReal_Add(self, theKey1)

    def Contains(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfReal_Contains(self, theKey1)

    def Substitute(self, theIndex, theKey1):
        return _TColStd.TColStd_IndexedMapOfReal_Substitute(self, theIndex, theKey1)

    def Swap(self, theIndex1, theIndex2):
        return _TColStd.TColStd_IndexedMapOfReal_Swap(self, theIndex1, theIndex2)

    def RemoveLast(self):
        return _TColStd.TColStd_IndexedMapOfReal_RemoveLast(self)

    def RemoveFromIndex(self, theIndex):
        return _TColStd.TColStd_IndexedMapOfReal_RemoveFromIndex(self, theIndex)

    def RemoveKey(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfReal_RemoveKey(self, theKey1)

    def FindKey(self, theIndex):
        return _TColStd.TColStd_IndexedMapOfReal_FindKey(self, theIndex)

    def __call__(self, theIndex):
        return _TColStd.TColStd_IndexedMapOfReal___call__(self, theIndex)

    def FindIndex(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfReal_FindIndex(self, theKey1)

    def Clear(self, *args):
        return _TColStd.TColStd_IndexedMapOfReal_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_IndexedMapOfReal

    def Size(self):
        return _TColStd.TColStd_IndexedMapOfReal_Size(self)

# Register TColStd_IndexedMapOfReal in _TColStd:
_TColStd.TColStd_IndexedMapOfReal_swigregister(TColStd_IndexedMapOfReal)
class TColStd_IndexedMapOfTransient(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def cbegin(self):
        return _TColStd.TColStd_IndexedMapOfTransient_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_IndexedMapOfTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_IndexedMapOfTransient_swiginit(self, _TColStd.new_TColStd_IndexedMapOfTransient(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_IndexedMapOfTransient_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_IndexedMapOfTransient_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_IndexedMapOfTransient_Set(self, theOther)

    def ReSize(self, theExtent):
        return _TColStd.TColStd_IndexedMapOfTransient_ReSize(self, theExtent)

    def Add(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfTransient_Add(self, theKey1)

    def Contains(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfTransient_Contains(self, theKey1)

    def Substitute(self, theIndex, theKey1):
        return _TColStd.TColStd_IndexedMapOfTransient_Substitute(self, theIndex, theKey1)

    def Swap(self, theIndex1, theIndex2):
        return _TColStd.TColStd_IndexedMapOfTransient_Swap(self, theIndex1, theIndex2)

    def RemoveLast(self):
        return _TColStd.TColStd_IndexedMapOfTransient_RemoveLast(self)

    def RemoveFromIndex(self, theIndex):
        return _TColStd.TColStd_IndexedMapOfTransient_RemoveFromIndex(self, theIndex)

    def RemoveKey(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfTransient_RemoveKey(self, theKey1)

    def FindKey(self, theIndex):
        return _TColStd.TColStd_IndexedMapOfTransient_FindKey(self, theIndex)

    def __call__(self, theIndex):
        return _TColStd.TColStd_IndexedMapOfTransient___call__(self, theIndex)

    def FindIndex(self, theKey1):
        return _TColStd.TColStd_IndexedMapOfTransient_FindIndex(self, theKey1)

    def Clear(self, *args):
        return _TColStd.TColStd_IndexedMapOfTransient_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_IndexedMapOfTransient

    def Size(self):
        return _TColStd.TColStd_IndexedMapOfTransient_Size(self)

# Register TColStd_IndexedMapOfTransient in _TColStd:
_TColStd.TColStd_IndexedMapOfTransient_swigregister(TColStd_IndexedMapOfTransient)
class TColStd_ListIteratorOfListOfAsciiString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _TColStd.TColStd_ListIteratorOfListOfAsciiString_swiginit(self, _TColStd.new_TColStd_ListIteratorOfListOfAsciiString(*args))

    def More(self):
        return _TColStd.TColStd_ListIteratorOfListOfAsciiString_More(self)

    def Next(self):
        return _TColStd.TColStd_ListIteratorOfListOfAsciiString_Next(self)

    def Value(self):
        return _TColStd.TColStd_ListIteratorOfListOfAsciiString_Value(self)

    def ChangeValue(self):
        return _TColStd.TColStd_ListIteratorOfListOfAsciiString_ChangeValue(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListIteratorOfListOfAsciiString

# Register TColStd_ListIteratorOfListOfAsciiString in _TColStd:
_TColStd.TColStd_ListIteratorOfListOfAsciiString_swigregister(TColStd_ListIteratorOfListOfAsciiString)
class TColStd_ListIteratorOfListOfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _TColStd.TColStd_ListIteratorOfListOfInteger_swiginit(self, _TColStd.new_TColStd_ListIteratorOfListOfInteger(*args))

    def More(self):
        return _TColStd.TColStd_ListIteratorOfListOfInteger_More(self)

    def Next(self):
        return _TColStd.TColStd_ListIteratorOfListOfInteger_Next(self)

    def Value(self):
        return _TColStd.TColStd_ListIteratorOfListOfInteger_Value(self)

    def ChangeValue(self):
        return _TColStd.TColStd_ListIteratorOfListOfInteger_ChangeValue(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListIteratorOfListOfInteger

# Register TColStd_ListIteratorOfListOfInteger in _TColStd:
_TColStd.TColStd_ListIteratorOfListOfInteger_swigregister(TColStd_ListIteratorOfListOfInteger)
class TColStd_ListIteratorOfListOfReal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _TColStd.TColStd_ListIteratorOfListOfReal_swiginit(self, _TColStd.new_TColStd_ListIteratorOfListOfReal(*args))

    def More(self):
        return _TColStd.TColStd_ListIteratorOfListOfReal_More(self)

    def Next(self):
        return _TColStd.TColStd_ListIteratorOfListOfReal_Next(self)

    def Value(self):
        return _TColStd.TColStd_ListIteratorOfListOfReal_Value(self)

    def ChangeValue(self):
        return _TColStd.TColStd_ListIteratorOfListOfReal_ChangeValue(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListIteratorOfListOfReal

# Register TColStd_ListIteratorOfListOfReal in _TColStd:
_TColStd.TColStd_ListIteratorOfListOfReal_swigregister(TColStd_ListIteratorOfListOfReal)
class TColStd_ListIteratorOfListOfTransient(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _TColStd.TColStd_ListIteratorOfListOfTransient_swiginit(self, _TColStd.new_TColStd_ListIteratorOfListOfTransient(*args))

    def More(self):
        return _TColStd.TColStd_ListIteratorOfListOfTransient_More(self)

    def Next(self):
        return _TColStd.TColStd_ListIteratorOfListOfTransient_Next(self)

    def Value(self):
        return _TColStd.TColStd_ListIteratorOfListOfTransient_Value(self)

    def ChangeValue(self):
        return _TColStd.TColStd_ListIteratorOfListOfTransient_ChangeValue(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListIteratorOfListOfTransient

# Register TColStd_ListIteratorOfListOfTransient in _TColStd:
_TColStd.TColStd_ListIteratorOfListOfTransient_swigregister(TColStd_ListIteratorOfListOfTransient)
class TColStd_ListOfAsciiString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_ListOfAsciiString_begin(self)

    def end(self):
        return _TColStd.TColStd_ListOfAsciiString_end(self)

    def cbegin(self):
        return _TColStd.TColStd_ListOfAsciiString_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_ListOfAsciiString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_ListOfAsciiString_swiginit(self, _TColStd.new_TColStd_ListOfAsciiString(*args))

    def Size(self):
        return _TColStd.TColStd_ListOfAsciiString_Size(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_ListOfAsciiString_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_ListOfAsciiString_Set(self, theOther)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_ListOfAsciiString_Clear(self, theAllocator)

    def First(self):
        return _TColStd.TColStd_ListOfAsciiString_First(self)

    def Last(self):
        return _TColStd.TColStd_ListOfAsciiString_Last(self)

    def Append(self, *args):
        return _TColStd.TColStd_ListOfAsciiString_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_ListOfAsciiString_Prepend(self, *args)

    def RemoveFirst(self):
        return _TColStd.TColStd_ListOfAsciiString_RemoveFirst(self)

    def Remove(self, theIter):
        return _TColStd.TColStd_ListOfAsciiString_Remove(self, theIter)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_ListOfAsciiString_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_ListOfAsciiString_InsertAfter(self, *args)

    def Reverse(self):
        return _TColStd.TColStd_ListOfAsciiString_Reverse(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListOfAsciiString

    def __len__(self):
        return self.Size()


# Register TColStd_ListOfAsciiString in _TColStd:
_TColStd.TColStd_ListOfAsciiString_swigregister(TColStd_ListOfAsciiString)
class TColStd_ListOfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_ListOfInteger_begin(self)

    def end(self):
        return _TColStd.TColStd_ListOfInteger_end(self)

    def cbegin(self):
        return _TColStd.TColStd_ListOfInteger_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_ListOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_ListOfInteger_swiginit(self, _TColStd.new_TColStd_ListOfInteger(*args))

    def Size(self):
        return _TColStd.TColStd_ListOfInteger_Size(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_ListOfInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_ListOfInteger_Set(self, theOther)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_ListOfInteger_Clear(self, theAllocator)

    def First(self):
        return _TColStd.TColStd_ListOfInteger_First(self)

    def Last(self):
        return _TColStd.TColStd_ListOfInteger_Last(self)

    def Append(self, *args):
        return _TColStd.TColStd_ListOfInteger_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_ListOfInteger_Prepend(self, *args)

    def RemoveFirst(self):
        return _TColStd.TColStd_ListOfInteger_RemoveFirst(self)

    def Remove(self, theIter):
        return _TColStd.TColStd_ListOfInteger_Remove(self, theIter)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_ListOfInteger_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_ListOfInteger_InsertAfter(self, *args)

    def Reverse(self):
        return _TColStd.TColStd_ListOfInteger_Reverse(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListOfInteger

    def __len__(self):
        return self.Size()


# Register TColStd_ListOfInteger in _TColStd:
_TColStd.TColStd_ListOfInteger_swigregister(TColStd_ListOfInteger)
class TColStd_ListOfReal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_ListOfReal_begin(self)

    def end(self):
        return _TColStd.TColStd_ListOfReal_end(self)

    def cbegin(self):
        return _TColStd.TColStd_ListOfReal_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_ListOfReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_ListOfReal_swiginit(self, _TColStd.new_TColStd_ListOfReal(*args))

    def Size(self):
        return _TColStd.TColStd_ListOfReal_Size(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_ListOfReal_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_ListOfReal_Set(self, theOther)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_ListOfReal_Clear(self, theAllocator)

    def First(self):
        return _TColStd.TColStd_ListOfReal_First(self)

    def Last(self):
        return _TColStd.TColStd_ListOfReal_Last(self)

    def Append(self, *args):
        return _TColStd.TColStd_ListOfReal_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_ListOfReal_Prepend(self, *args)

    def RemoveFirst(self):
        return _TColStd.TColStd_ListOfReal_RemoveFirst(self)

    def Remove(self, theIter):
        return _TColStd.TColStd_ListOfReal_Remove(self, theIter)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_ListOfReal_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_ListOfReal_InsertAfter(self, *args)

    def Reverse(self):
        return _TColStd.TColStd_ListOfReal_Reverse(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListOfReal

    def __len__(self):
        return self.Size()


# Register TColStd_ListOfReal in _TColStd:
_TColStd.TColStd_ListOfReal_swigregister(TColStd_ListOfReal)
class TColStd_ListOfTransient(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_ListOfTransient_begin(self)

    def end(self):
        return _TColStd.TColStd_ListOfTransient_end(self)

    def cbegin(self):
        return _TColStd.TColStd_ListOfTransient_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_ListOfTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_ListOfTransient_swiginit(self, _TColStd.new_TColStd_ListOfTransient(*args))

    def Size(self):
        return _TColStd.TColStd_ListOfTransient_Size(self)

    def Assign(self, theOther):
        return _TColStd.TColStd_ListOfTransient_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_ListOfTransient_Set(self, theOther)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_ListOfTransient_Clear(self, theAllocator)

    def First(self):
        return _TColStd.TColStd_ListOfTransient_First(self)

    def Last(self):
        return _TColStd.TColStd_ListOfTransient_Last(self)

    def Append(self, *args):
        return _TColStd.TColStd_ListOfTransient_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_ListOfTransient_Prepend(self, *args)

    def RemoveFirst(self):
        return _TColStd.TColStd_ListOfTransient_RemoveFirst(self)

    def Remove(self, theIter):
        return _TColStd.TColStd_ListOfTransient_Remove(self, theIter)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_ListOfTransient_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_ListOfTransient_InsertAfter(self, *args)

    def Reverse(self):
        return _TColStd.TColStd_ListOfTransient_Reverse(self)
    __swig_destroy__ = _TColStd.delete_TColStd_ListOfTransient

    def __len__(self):
        return self.Size()


# Register TColStd_ListOfTransient in _TColStd:
_TColStd.TColStd_ListOfTransient_swigregister(TColStd_ListOfTransient)
class TColStd_MapIntegerHasher(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def HashCode(theKey, theUpperBound):
        return _TColStd.TColStd_MapIntegerHasher_HashCode(theKey, theUpperBound)

    @staticmethod
    def IsEqual(theKey1, theKey2):
        return _TColStd.TColStd_MapIntegerHasher_IsEqual(theKey1, theKey2)

    def __init__(self):
        _TColStd.TColStd_MapIntegerHasher_swiginit(self, _TColStd.new_TColStd_MapIntegerHasher())
    __swig_destroy__ = _TColStd.delete_TColStd_MapIntegerHasher

# Register TColStd_MapIntegerHasher in _TColStd:
_TColStd.TColStd_MapIntegerHasher_swigregister(TColStd_MapIntegerHasher)
class TColStd_MapOfAsciiString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def cbegin(self):
        return _TColStd.TColStd_MapOfAsciiString_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_MapOfAsciiString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_MapOfAsciiString_swiginit(self, _TColStd.new_TColStd_MapOfAsciiString(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_MapOfAsciiString_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_MapOfAsciiString_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_MapOfAsciiString_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_MapOfAsciiString_ReSize(self, N)

    def Add(self, K):
        return _TColStd.TColStd_MapOfAsciiString_Add(self, K)

    def Added(self, K):
        return _TColStd.TColStd_MapOfAsciiString_Added(self, K)

    def Remove(self, K):
        return _TColStd.TColStd_MapOfAsciiString_Remove(self, K)

    def Clear(self, *args):
        return _TColStd.TColStd_MapOfAsciiString_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_MapOfAsciiString

    def Size(self):
        return _TColStd.TColStd_MapOfAsciiString_Size(self)

    def IsEqual(self, theOther):
        return _TColStd.TColStd_MapOfAsciiString_IsEqual(self, theOther)

    def Contains(self, *args):
        return _TColStd.TColStd_MapOfAsciiString_Contains(self, *args)

    def Union(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfAsciiString_Union(self, theLeft, theRight)

    def Unite(self, theOther):
        return _TColStd.TColStd_MapOfAsciiString_Unite(self, theOther)

    def HasIntersection(self, theMap):
        return _TColStd.TColStd_MapOfAsciiString_HasIntersection(self, theMap)

    def Intersection(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfAsciiString_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther):
        return _TColStd.TColStd_MapOfAsciiString_Intersect(self, theOther)

    def Subtraction(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfAsciiString_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther):
        return _TColStd.TColStd_MapOfAsciiString_Subtract(self, theOther)

    def Difference(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfAsciiString_Difference(self, theLeft, theRight)

    def Differ(self, theOther):
        return _TColStd.TColStd_MapOfAsciiString_Differ(self, theOther)

# Register TColStd_MapOfAsciiString in _TColStd:
_TColStd.TColStd_MapOfAsciiString_swigregister(TColStd_MapOfAsciiString)
class TColStd_MapOfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def cbegin(self):
        return _TColStd.TColStd_MapOfInteger_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_MapOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_MapOfInteger_swiginit(self, _TColStd.new_TColStd_MapOfInteger(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_MapOfInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_MapOfInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_MapOfInteger_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_MapOfInteger_ReSize(self, N)

    def Add(self, K):
        return _TColStd.TColStd_MapOfInteger_Add(self, K)

    def Added(self, K):
        return _TColStd.TColStd_MapOfInteger_Added(self, K)

    def Remove(self, K):
        return _TColStd.TColStd_MapOfInteger_Remove(self, K)

    def Clear(self, *args):
        return _TColStd.TColStd_MapOfInteger_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_MapOfInteger

    def Size(self):
        return _TColStd.TColStd_MapOfInteger_Size(self)

    def IsEqual(self, theOther):
        return _TColStd.TColStd_MapOfInteger_IsEqual(self, theOther)

    def Contains(self, *args):
        return _TColStd.TColStd_MapOfInteger_Contains(self, *args)

    def Union(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfInteger_Union(self, theLeft, theRight)

    def Unite(self, theOther):
        return _TColStd.TColStd_MapOfInteger_Unite(self, theOther)

    def HasIntersection(self, theMap):
        return _TColStd.TColStd_MapOfInteger_HasIntersection(self, theMap)

    def Intersection(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfInteger_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther):
        return _TColStd.TColStd_MapOfInteger_Intersect(self, theOther)

    def Subtraction(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfInteger_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther):
        return _TColStd.TColStd_MapOfInteger_Subtract(self, theOther)

    def Difference(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfInteger_Difference(self, theLeft, theRight)

    def Differ(self, theOther):
        return _TColStd.TColStd_MapOfInteger_Differ(self, theOther)

# Register TColStd_MapOfInteger in _TColStd:
_TColStd.TColStd_MapOfInteger_swigregister(TColStd_MapOfInteger)
class TColStd_MapOfReal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def cbegin(self):
        return _TColStd.TColStd_MapOfReal_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_MapOfReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_MapOfReal_swiginit(self, _TColStd.new_TColStd_MapOfReal(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_MapOfReal_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_MapOfReal_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_MapOfReal_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_MapOfReal_ReSize(self, N)

    def Add(self, K):
        return _TColStd.TColStd_MapOfReal_Add(self, K)

    def Added(self, K):
        return _TColStd.TColStd_MapOfReal_Added(self, K)

    def Remove(self, K):
        return _TColStd.TColStd_MapOfReal_Remove(self, K)

    def Clear(self, *args):
        return _TColStd.TColStd_MapOfReal_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_MapOfReal

    def Size(self):
        return _TColStd.TColStd_MapOfReal_Size(self)

    def IsEqual(self, theOther):
        return _TColStd.TColStd_MapOfReal_IsEqual(self, theOther)

    def Contains(self, *args):
        return _TColStd.TColStd_MapOfReal_Contains(self, *args)

    def Union(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfReal_Union(self, theLeft, theRight)

    def Unite(self, theOther):
        return _TColStd.TColStd_MapOfReal_Unite(self, theOther)

    def HasIntersection(self, theMap):
        return _TColStd.TColStd_MapOfReal_HasIntersection(self, theMap)

    def Intersection(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfReal_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther):
        return _TColStd.TColStd_MapOfReal_Intersect(self, theOther)

    def Subtraction(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfReal_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther):
        return _TColStd.TColStd_MapOfReal_Subtract(self, theOther)

    def Difference(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfReal_Difference(self, theLeft, theRight)

    def Differ(self, theOther):
        return _TColStd.TColStd_MapOfReal_Differ(self, theOther)

# Register TColStd_MapOfReal in _TColStd:
_TColStd.TColStd_MapOfReal_swigregister(TColStd_MapOfReal)
class TColStd_MapOfTransient(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def cbegin(self):
        return _TColStd.TColStd_MapOfTransient_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_MapOfTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_MapOfTransient_swiginit(self, _TColStd.new_TColStd_MapOfTransient(*args))

    def Exchange(self, theOther):
        return _TColStd.TColStd_MapOfTransient_Exchange(self, theOther)

    def Assign(self, theOther):
        return _TColStd.TColStd_MapOfTransient_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_MapOfTransient_Set(self, theOther)

    def ReSize(self, N):
        return _TColStd.TColStd_MapOfTransient_ReSize(self, N)

    def Add(self, K):
        return _TColStd.TColStd_MapOfTransient_Add(self, K)

    def Added(self, K):
        return _TColStd.TColStd_MapOfTransient_Added(self, K)

    def Remove(self, K):
        return _TColStd.TColStd_MapOfTransient_Remove(self, K)

    def Clear(self, *args):
        return _TColStd.TColStd_MapOfTransient_Clear(self, *args)
    __swig_destroy__ = _TColStd.delete_TColStd_MapOfTransient

    def Size(self):
        return _TColStd.TColStd_MapOfTransient_Size(self)

    def IsEqual(self, theOther):
        return _TColStd.TColStd_MapOfTransient_IsEqual(self, theOther)

    def Contains(self, *args):
        return _TColStd.TColStd_MapOfTransient_Contains(self, *args)

    def Union(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfTransient_Union(self, theLeft, theRight)

    def Unite(self, theOther):
        return _TColStd.TColStd_MapOfTransient_Unite(self, theOther)

    def HasIntersection(self, theMap):
        return _TColStd.TColStd_MapOfTransient_HasIntersection(self, theMap)

    def Intersection(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfTransient_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther):
        return _TColStd.TColStd_MapOfTransient_Intersect(self, theOther)

    def Subtraction(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfTransient_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther):
        return _TColStd.TColStd_MapOfTransient_Subtract(self, theOther)

    def Difference(self, theLeft, theRight):
        return _TColStd.TColStd_MapOfTransient_Difference(self, theLeft, theRight)

    def Differ(self, theOther):
        return _TColStd.TColStd_MapOfTransient_Differ(self, theOther)

# Register TColStd_MapOfTransient in _TColStd:
_TColStd.TColStd_MapOfTransient_swigregister(TColStd_MapOfTransient)
class TColStd_MapRealHasher(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def HashCode(theKey, theUpperBound):
        return _TColStd.TColStd_MapRealHasher_HashCode(theKey, theUpperBound)

    @staticmethod
    def IsEqual(theKey1, theKey2):
        return _TColStd.TColStd_MapRealHasher_IsEqual(theKey1, theKey2)

    def __init__(self):
        _TColStd.TColStd_MapRealHasher_swiginit(self, _TColStd.new_TColStd_MapRealHasher())
    __swig_destroy__ = _TColStd.delete_TColStd_MapRealHasher

# Register TColStd_MapRealHasher in _TColStd:
_TColStd.TColStd_MapRealHasher_swigregister(TColStd_MapRealHasher)
class TColStd_MapTransientHasher(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def HashCode(theKey, theUpperBound):
        return _TColStd.TColStd_MapTransientHasher_HashCode(theKey, theUpperBound)

    @staticmethod
    def IsEqual(theKey1, theKey2):
        return _TColStd.TColStd_MapTransientHasher_IsEqual(theKey1, theKey2)

    def __init__(self):
        _TColStd.TColStd_MapTransientHasher_swiginit(self, _TColStd.new_TColStd_MapTransientHasher())
    __swig_destroy__ = _TColStd.delete_TColStd_MapTransientHasher

# Register TColStd_MapTransientHasher in _TColStd:
_TColStd.TColStd_MapTransientHasher_swigregister(TColStd_MapTransientHasher)
class TColStd_SequenceOfAddress(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_SequenceOfAddress_begin(self)

    def end(self):
        return _TColStd.TColStd_SequenceOfAddress_end(self)

    def cbegin(self):
        return _TColStd.TColStd_SequenceOfAddress_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_SequenceOfAddress_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfAddress_swiginit(self, _TColStd.new_TColStd_SequenceOfAddress(*args))

    def Size(self):
        return _TColStd.TColStd_SequenceOfAddress_Size(self)

    def Length(self):
        return _TColStd.TColStd_SequenceOfAddress_Length(self)

    def Lower(self):
        return _TColStd.TColStd_SequenceOfAddress_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_SequenceOfAddress_Upper(self)

    def IsEmpty(self):
        return _TColStd.TColStd_SequenceOfAddress_IsEmpty(self)

    def Reverse(self):
        return _TColStd.TColStd_SequenceOfAddress_Reverse(self)

    def Exchange(self, I, J):
        return _TColStd.TColStd_SequenceOfAddress_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _TColStd.TColStd_SequenceOfAddress_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_SequenceOfAddress_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _TColStd.TColStd_SequenceOfAddress_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_SequenceOfAddress_Set(self, theOther)

    def Remove(self, *args):
        return _TColStd.TColStd_SequenceOfAddress_Remove(self, *args)

    def Append(self, *args):
        return _TColStd.TColStd_SequenceOfAddress_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_SequenceOfAddress_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_SequenceOfAddress_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_SequenceOfAddress_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _TColStd.TColStd_SequenceOfAddress_Split(self, theIndex, theSeq)

    def First(self):
        return _TColStd.TColStd_SequenceOfAddress_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_SequenceOfAddress_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_SequenceOfAddress_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_SequenceOfAddress_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_SequenceOfAddress_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_SequenceOfAddress_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_SequenceOfAddress___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_SequenceOfAddress_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfAddress

# Register TColStd_SequenceOfAddress in _TColStd:
_TColStd.TColStd_SequenceOfAddress_swigregister(TColStd_SequenceOfAddress)
class TColStd_SequenceOfAsciiString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_SequenceOfAsciiString_begin(self)

    def end(self):
        return _TColStd.TColStd_SequenceOfAsciiString_end(self)

    def cbegin(self):
        return _TColStd.TColStd_SequenceOfAsciiString_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_SequenceOfAsciiString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfAsciiString_swiginit(self, _TColStd.new_TColStd_SequenceOfAsciiString(*args))

    def Size(self):
        return _TColStd.TColStd_SequenceOfAsciiString_Size(self)

    def Length(self):
        return _TColStd.TColStd_SequenceOfAsciiString_Length(self)

    def Lower(self):
        return _TColStd.TColStd_SequenceOfAsciiString_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_SequenceOfAsciiString_Upper(self)

    def IsEmpty(self):
        return _TColStd.TColStd_SequenceOfAsciiString_IsEmpty(self)

    def Reverse(self):
        return _TColStd.TColStd_SequenceOfAsciiString_Reverse(self)

    def Exchange(self, I, J):
        return _TColStd.TColStd_SequenceOfAsciiString_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _TColStd.TColStd_SequenceOfAsciiString_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_SequenceOfAsciiString_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _TColStd.TColStd_SequenceOfAsciiString_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_SequenceOfAsciiString_Set(self, theOther)

    def Remove(self, *args):
        return _TColStd.TColStd_SequenceOfAsciiString_Remove(self, *args)

    def Append(self, *args):
        return _TColStd.TColStd_SequenceOfAsciiString_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_SequenceOfAsciiString_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_SequenceOfAsciiString_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_SequenceOfAsciiString_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _TColStd.TColStd_SequenceOfAsciiString_Split(self, theIndex, theSeq)

    def First(self):
        return _TColStd.TColStd_SequenceOfAsciiString_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_SequenceOfAsciiString_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_SequenceOfAsciiString_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_SequenceOfAsciiString_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_SequenceOfAsciiString_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_SequenceOfAsciiString_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_SequenceOfAsciiString___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_SequenceOfAsciiString_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfAsciiString

    def __len__(self):
        return self.Size()


# Register TColStd_SequenceOfAsciiString in _TColStd:
_TColStd.TColStd_SequenceOfAsciiString_swigregister(TColStd_SequenceOfAsciiString)
class TColStd_SequenceOfBoolean(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_SequenceOfBoolean_begin(self)

    def end(self):
        return _TColStd.TColStd_SequenceOfBoolean_end(self)

    def cbegin(self):
        return _TColStd.TColStd_SequenceOfBoolean_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_SequenceOfBoolean_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfBoolean_swiginit(self, _TColStd.new_TColStd_SequenceOfBoolean(*args))

    def Size(self):
        return _TColStd.TColStd_SequenceOfBoolean_Size(self)

    def Length(self):
        return _TColStd.TColStd_SequenceOfBoolean_Length(self)

    def Lower(self):
        return _TColStd.TColStd_SequenceOfBoolean_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_SequenceOfBoolean_Upper(self)

    def IsEmpty(self):
        return _TColStd.TColStd_SequenceOfBoolean_IsEmpty(self)

    def Reverse(self):
        return _TColStd.TColStd_SequenceOfBoolean_Reverse(self)

    def Exchange(self, I, J):
        return _TColStd.TColStd_SequenceOfBoolean_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _TColStd.TColStd_SequenceOfBoolean_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_SequenceOfBoolean_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _TColStd.TColStd_SequenceOfBoolean_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_SequenceOfBoolean_Set(self, theOther)

    def Remove(self, *args):
        return _TColStd.TColStd_SequenceOfBoolean_Remove(self, *args)

    def Append(self, *args):
        return _TColStd.TColStd_SequenceOfBoolean_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_SequenceOfBoolean_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_SequenceOfBoolean_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_SequenceOfBoolean_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _TColStd.TColStd_SequenceOfBoolean_Split(self, theIndex, theSeq)

    def First(self):
        return _TColStd.TColStd_SequenceOfBoolean_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_SequenceOfBoolean_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_SequenceOfBoolean_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_SequenceOfBoolean_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_SequenceOfBoolean_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_SequenceOfBoolean_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_SequenceOfBoolean___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_SequenceOfBoolean_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfBoolean

    def __len__(self):
        return self.Size()


# Register TColStd_SequenceOfBoolean in _TColStd:
_TColStd.TColStd_SequenceOfBoolean_swigregister(TColStd_SequenceOfBoolean)
class TColStd_SequenceOfExtendedString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_SequenceOfExtendedString_begin(self)

    def end(self):
        return _TColStd.TColStd_SequenceOfExtendedString_end(self)

    def cbegin(self):
        return _TColStd.TColStd_SequenceOfExtendedString_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_SequenceOfExtendedString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfExtendedString_swiginit(self, _TColStd.new_TColStd_SequenceOfExtendedString(*args))

    def Size(self):
        return _TColStd.TColStd_SequenceOfExtendedString_Size(self)

    def Length(self):
        return _TColStd.TColStd_SequenceOfExtendedString_Length(self)

    def Lower(self):
        return _TColStd.TColStd_SequenceOfExtendedString_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_SequenceOfExtendedString_Upper(self)

    def IsEmpty(self):
        return _TColStd.TColStd_SequenceOfExtendedString_IsEmpty(self)

    def Reverse(self):
        return _TColStd.TColStd_SequenceOfExtendedString_Reverse(self)

    def Exchange(self, I, J):
        return _TColStd.TColStd_SequenceOfExtendedString_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _TColStd.TColStd_SequenceOfExtendedString_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_SequenceOfExtendedString_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _TColStd.TColStd_SequenceOfExtendedString_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_SequenceOfExtendedString_Set(self, theOther)

    def Remove(self, *args):
        return _TColStd.TColStd_SequenceOfExtendedString_Remove(self, *args)

    def Append(self, *args):
        return _TColStd.TColStd_SequenceOfExtendedString_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_SequenceOfExtendedString_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_SequenceOfExtendedString_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_SequenceOfExtendedString_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _TColStd.TColStd_SequenceOfExtendedString_Split(self, theIndex, theSeq)

    def First(self):
        return _TColStd.TColStd_SequenceOfExtendedString_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_SequenceOfExtendedString_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_SequenceOfExtendedString_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_SequenceOfExtendedString_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_SequenceOfExtendedString_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_SequenceOfExtendedString_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_SequenceOfExtendedString___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_SequenceOfExtendedString_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfExtendedString

    def __len__(self):
        return self.Size()


# Register TColStd_SequenceOfExtendedString in _TColStd:
_TColStd.TColStd_SequenceOfExtendedString_swigregister(TColStd_SequenceOfExtendedString)
class TColStd_SequenceOfHAsciiString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_begin(self)

    def end(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_end(self)

    def cbegin(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfHAsciiString_swiginit(self, _TColStd.new_TColStd_SequenceOfHAsciiString(*args))

    def Size(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_Size(self)

    def Length(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_Length(self)

    def Lower(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_Upper(self)

    def IsEmpty(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_IsEmpty(self)

    def Reverse(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_Reverse(self)

    def Exchange(self, I, J):
        return _TColStd.TColStd_SequenceOfHAsciiString_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _TColStd.TColStd_SequenceOfHAsciiString_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_SequenceOfHAsciiString_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _TColStd.TColStd_SequenceOfHAsciiString_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_SequenceOfHAsciiString_Set(self, theOther)

    def Remove(self, *args):
        return _TColStd.TColStd_SequenceOfHAsciiString_Remove(self, *args)

    def Append(self, *args):
        return _TColStd.TColStd_SequenceOfHAsciiString_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_SequenceOfHAsciiString_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_SequenceOfHAsciiString_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_SequenceOfHAsciiString_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _TColStd.TColStd_SequenceOfHAsciiString_Split(self, theIndex, theSeq)

    def First(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_SequenceOfHAsciiString_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_SequenceOfHAsciiString_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_SequenceOfHAsciiString_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_SequenceOfHAsciiString___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_SequenceOfHAsciiString_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfHAsciiString

    def __len__(self):
        return self.Size()


# Register TColStd_SequenceOfHAsciiString in _TColStd:
_TColStd.TColStd_SequenceOfHAsciiString_swigregister(TColStd_SequenceOfHAsciiString)
class TColStd_SequenceOfHExtendedString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_begin(self)

    def end(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_end(self)

    def cbegin(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfHExtendedString_swiginit(self, _TColStd.new_TColStd_SequenceOfHExtendedString(*args))

    def Size(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_Size(self)

    def Length(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_Length(self)

    def Lower(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_Upper(self)

    def IsEmpty(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_IsEmpty(self)

    def Reverse(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_Reverse(self)

    def Exchange(self, I, J):
        return _TColStd.TColStd_SequenceOfHExtendedString_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _TColStd.TColStd_SequenceOfHExtendedString_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_SequenceOfHExtendedString_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _TColStd.TColStd_SequenceOfHExtendedString_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_SequenceOfHExtendedString_Set(self, theOther)

    def Remove(self, *args):
        return _TColStd.TColStd_SequenceOfHExtendedString_Remove(self, *args)

    def Append(self, *args):
        return _TColStd.TColStd_SequenceOfHExtendedString_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_SequenceOfHExtendedString_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_SequenceOfHExtendedString_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_SequenceOfHExtendedString_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _TColStd.TColStd_SequenceOfHExtendedString_Split(self, theIndex, theSeq)

    def First(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_SequenceOfHExtendedString_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_SequenceOfHExtendedString_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_SequenceOfHExtendedString_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_SequenceOfHExtendedString___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_SequenceOfHExtendedString_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfHExtendedString

    def __len__(self):
        return self.Size()


# Register TColStd_SequenceOfHExtendedString in _TColStd:
_TColStd.TColStd_SequenceOfHExtendedString_swigregister(TColStd_SequenceOfHExtendedString)
class TColStd_SequenceOfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_SequenceOfInteger_begin(self)

    def end(self):
        return _TColStd.TColStd_SequenceOfInteger_end(self)

    def cbegin(self):
        return _TColStd.TColStd_SequenceOfInteger_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_SequenceOfInteger_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfInteger_swiginit(self, _TColStd.new_TColStd_SequenceOfInteger(*args))

    def Size(self):
        return _TColStd.TColStd_SequenceOfInteger_Size(self)

    def Length(self):
        return _TColStd.TColStd_SequenceOfInteger_Length(self)

    def Lower(self):
        return _TColStd.TColStd_SequenceOfInteger_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_SequenceOfInteger_Upper(self)

    def IsEmpty(self):
        return _TColStd.TColStd_SequenceOfInteger_IsEmpty(self)

    def Reverse(self):
        return _TColStd.TColStd_SequenceOfInteger_Reverse(self)

    def Exchange(self, I, J):
        return _TColStd.TColStd_SequenceOfInteger_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _TColStd.TColStd_SequenceOfInteger_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_SequenceOfInteger_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _TColStd.TColStd_SequenceOfInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_SequenceOfInteger_Set(self, theOther)

    def Remove(self, *args):
        return _TColStd.TColStd_SequenceOfInteger_Remove(self, *args)

    def Append(self, *args):
        return _TColStd.TColStd_SequenceOfInteger_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_SequenceOfInteger_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_SequenceOfInteger_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_SequenceOfInteger_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _TColStd.TColStd_SequenceOfInteger_Split(self, theIndex, theSeq)

    def First(self):
        return _TColStd.TColStd_SequenceOfInteger_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_SequenceOfInteger_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_SequenceOfInteger_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_SequenceOfInteger_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_SequenceOfInteger_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_SequenceOfInteger_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_SequenceOfInteger___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_SequenceOfInteger_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfInteger

    def __len__(self):
        return self.Size()


# Register TColStd_SequenceOfInteger in _TColStd:
_TColStd.TColStd_SequenceOfInteger_swigregister(TColStd_SequenceOfInteger)
class TColStd_SequenceOfReal(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_SequenceOfReal_begin(self)

    def end(self):
        return _TColStd.TColStd_SequenceOfReal_end(self)

    def cbegin(self):
        return _TColStd.TColStd_SequenceOfReal_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_SequenceOfReal_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfReal_swiginit(self, _TColStd.new_TColStd_SequenceOfReal(*args))

    def Size(self):
        return _TColStd.TColStd_SequenceOfReal_Size(self)

    def Length(self):
        return _TColStd.TColStd_SequenceOfReal_Length(self)

    def Lower(self):
        return _TColStd.TColStd_SequenceOfReal_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_SequenceOfReal_Upper(self)

    def IsEmpty(self):
        return _TColStd.TColStd_SequenceOfReal_IsEmpty(self)

    def Reverse(self):
        return _TColStd.TColStd_SequenceOfReal_Reverse(self)

    def Exchange(self, I, J):
        return _TColStd.TColStd_SequenceOfReal_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _TColStd.TColStd_SequenceOfReal_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_SequenceOfReal_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _TColStd.TColStd_SequenceOfReal_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_SequenceOfReal_Set(self, theOther)

    def Remove(self, *args):
        return _TColStd.TColStd_SequenceOfReal_Remove(self, *args)

    def Append(self, *args):
        return _TColStd.TColStd_SequenceOfReal_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_SequenceOfReal_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_SequenceOfReal_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_SequenceOfReal_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _TColStd.TColStd_SequenceOfReal_Split(self, theIndex, theSeq)

    def First(self):
        return _TColStd.TColStd_SequenceOfReal_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_SequenceOfReal_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_SequenceOfReal_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_SequenceOfReal_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_SequenceOfReal_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_SequenceOfReal_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_SequenceOfReal___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_SequenceOfReal_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfReal

    def __len__(self):
        return self.Size()


# Register TColStd_SequenceOfReal in _TColStd:
_TColStd.TColStd_SequenceOfReal_swigregister(TColStd_SequenceOfReal)
class TColStd_SequenceOfTransient(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self):
        return _TColStd.TColStd_SequenceOfTransient_begin(self)

    def end(self):
        return _TColStd.TColStd_SequenceOfTransient_end(self)

    def cbegin(self):
        return _TColStd.TColStd_SequenceOfTransient_cbegin(self)

    def cend(self):
        return _TColStd.TColStd_SequenceOfTransient_cend(self)

    def __init__(self, *args):
        _TColStd.TColStd_SequenceOfTransient_swiginit(self, _TColStd.new_TColStd_SequenceOfTransient(*args))

    def Size(self):
        return _TColStd.TColStd_SequenceOfTransient_Size(self)

    def Length(self):
        return _TColStd.TColStd_SequenceOfTransient_Length(self)

    def Lower(self):
        return _TColStd.TColStd_SequenceOfTransient_Lower(self)

    def Upper(self):
        return _TColStd.TColStd_SequenceOfTransient_Upper(self)

    def IsEmpty(self):
        return _TColStd.TColStd_SequenceOfTransient_IsEmpty(self)

    def Reverse(self):
        return _TColStd.TColStd_SequenceOfTransient_Reverse(self)

    def Exchange(self, I, J):
        return _TColStd.TColStd_SequenceOfTransient_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _TColStd.TColStd_SequenceOfTransient_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _TColStd.TColStd_SequenceOfTransient_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _TColStd.TColStd_SequenceOfTransient_Assign(self, theOther)

    def Set(self, theOther):
        return _TColStd.TColStd_SequenceOfTransient_Set(self, theOther)

    def Remove(self, *args):
        return _TColStd.TColStd_SequenceOfTransient_Remove(self, *args)

    def Append(self, *args):
        return _TColStd.TColStd_SequenceOfTransient_Append(self, *args)

    def Prepend(self, *args):
        return _TColStd.TColStd_SequenceOfTransient_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _TColStd.TColStd_SequenceOfTransient_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _TColStd.TColStd_SequenceOfTransient_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _TColStd.TColStd_SequenceOfTransient_Split(self, theIndex, theSeq)

    def First(self):
        return _TColStd.TColStd_SequenceOfTransient_First(self)

    def ChangeFirst(self):
        return _TColStd.TColStd_SequenceOfTransient_ChangeFirst(self)

    def Last(self):
        return _TColStd.TColStd_SequenceOfTransient_Last(self)

    def ChangeLast(self):
        return _TColStd.TColStd_SequenceOfTransient_ChangeLast(self)

    def Value(self, theIndex):
        return _TColStd.TColStd_SequenceOfTransient_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _TColStd.TColStd_SequenceOfTransient_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _TColStd.TColStd_SequenceOfTransient___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _TColStd.TColStd_SequenceOfTransient_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _TColStd.delete_TColStd_SequenceOfTransient

    def __len__(self):
        return self.Size()


# Register TColStd_SequenceOfTransient in _TColStd:
_TColStd.TColStd_SequenceOfTransient_swigregister(TColStd_SequenceOfTransient)
class TColStd_HPackedMapOfInteger(OCC.Core.Standard.Standard_Transient):
    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"""

        Parameters
        ----------
        NbBuckets: int (optional, default to 1)

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        Parameters
        ----------
        theOther: TColStd_PackedMapOfInteger

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _TColStd.TColStd_HPackedMapOfInteger_swiginit(self, _TColStd.new_TColStd_HPackedMapOfInteger(*args))

    def ChangeMap(self, *args):
        r"""
        Return
        -------
        TColStd_PackedMapOfInteger

        Description
        -----------
        No available documentation.

        """
        return _TColStd.TColStd_HPackedMapOfInteger_ChangeMap(self, *args)

    def Map(self, *args):
        r"""
        Return
        -------
        TColStd_PackedMapOfInteger

        Description
        -----------
        No available documentation.

        """
        return _TColStd.TColStd_HPackedMapOfInteger_Map(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HPackedMapOfInteger_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _TColStd.delete_TColStd_HPackedMapOfInteger

# Register TColStd_HPackedMapOfInteger in _TColStd:
_TColStd.TColStd_HPackedMapOfInteger_swigregister(TColStd_HPackedMapOfInteger)
class TColStd_PackedMapOfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""

        Parameters
        ----------
        theNbBuckets: int (optional, default to 1)

        Return
        -------
        None

        Description
        -----------
        Constructor.

        Parameters
        ----------
        theOther: TColStd_PackedMapOfInteger

        Return
        -------
        None

        Description
        -----------
        Copy constructor.

        """
        _TColStd.TColStd_PackedMapOfInteger_swiginit(self, _TColStd.new_TColStd_PackedMapOfInteger(*args))

    def Add(self, *args):
        r"""

        Parameters
        ----------
        aKey: int

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Add(self, *args)

    def Assign(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger

        Return
        -------
        TColStd_PackedMapOfInteger

        Description
        -----------
        No available documentation.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Assign(self, *args)

    def Clear(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Clear(self, *args)

    def Contains(self, *args):
        r"""

        Parameters
        ----------
        aKey: int

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Contains(self, *args)

    def Differ(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger

        Return
        -------
        bool

        Description
        -----------
        /** * apply to this map the symmetric difference (aka exclusive disjunction, boolean xor) operation with another (given) map. * the result contains the values that are contained only in this or the operand map, but not in both. * this algorithm is similar to method difference(). * return true if contents of this map is changed */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Differ(self, *args)

    def Difference(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger
        &: TColStd_PackedMapOfInteger

        Return
        -------
        None

        Description
        -----------
        /** * sets this map to be the result of symmetric difference (aka exclusive disjunction, boolean xor) operation between two given maps. * the new map contains the values that are contained only in the first or the second operand maps but not in both. * all previous contents of this map is cleared. * this map (result of the boolean operation) can also be used as one of operands. */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Difference(self, *args)

    def Extent(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns map extent.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Extent(self, *args)

    def GetMaximalMapped(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        /** * query the maximal contained key value. */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_GetMaximalMapped(self, *args)

    def GetMinimalMapped(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        /** * query the minimal contained key value. */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_GetMinimalMapped(self, *args)

    def HasIntersection(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger

        Return
        -------
        bool

        Description
        -----------
        /** * returns true if this map has common items with the given one. */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_HasIntersection(self, *args)

    def Intersect(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger

        Return
        -------
        bool

        Description
        -----------
        /** * apply to this map the intersection operation (aka multiplication, common, boolean and) with another (given) map. * the result contains only the values that are contained in both this and the given maps. * this algorithm is similar to method intersection(). * return true if content of this map is changed */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Intersect(self, *args)

    def Intersection(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger
        &: TColStd_PackedMapOfInteger

        Return
        -------
        None

        Description
        -----------
        /** * sets this map to be the result of intersection (aka multiplication, common, boolean and) operation between two given maps. * the new map contains only the values that are contained in both map operands. * all previous contents of this map is cleared. this same map (result of the boolean operation) can also be used as one of operands. * the order of operands makes no difference; the method minimizes internally the number of iterations using the smallest map for the loop. */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Intersection(self, *args)

    def IsEmpty(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true if map is empty.

        """
        return _TColStd.TColStd_PackedMapOfInteger_IsEmpty(self, *args)

    def IsEqual(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger

        Return
        -------
        bool

        Description
        -----------
        /** * returns true if this map is equal to the given one, i.e. they contain the * same sets of elements */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_IsEqual(self, *args)

    def IsSubset(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger

        Return
        -------
        bool

        Description
        -----------
        /** * returns true if this map is subset of the given one, i.e. all elements * contained in this map is contained also in the operand map. * if this map is empty that this method returns true for any operand map. */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_IsSubset(self, *args)

    def NbBuckets(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the number of map buckets (not that since integers are packed in this map, the number is smaller than extent).

        """
        return _TColStd.TColStd_PackedMapOfInteger_NbBuckets(self, *args)

    def ReSize(self, *args):
        r"""

        Parameters
        ----------
        NbBuckets: int

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        return _TColStd.TColStd_PackedMapOfInteger_ReSize(self, *args)

    def Remove(self, *args):
        r"""

        Parameters
        ----------
        aKey: int

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Remove(self, *args)

    def StatisticsToString(self):
        r"""StatisticsToString(TColStd_PackedMapOfInteger self) -> std::string"""
        return _TColStd.TColStd_PackedMapOfInteger_StatisticsToString(self)

    def Subtract(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger

        Return
        -------
        bool

        Description
        -----------
        /** * apply to this map the subtraction (aka set-theoretic difference, relative complement, exclude, cut, boolean not) operation with another (given) map. * the result contains only the values that were previously contained in this map and not contained in this map. * this algorithm is similar to method subtract() with two operands. * return true if contents of this map is changed */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Subtract(self, *args)

    def Subtraction(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger
        &: TColStd_PackedMapOfInteger

        Return
        -------
        None

        Description
        -----------
        /** * sets this map to be the result of subtraction * (aka set-theoretic difference, relative complement, exclude, cut, boolean not) operation between two given maps. * the new map contains only the values that are contained in the first map operands and not contained in the second one. * all previous contents of this map is cleared. * this map (result of the boolean operation) can also be used as the first operand. */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Subtraction(self, *args)

    def Union(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger
        &: TColStd_PackedMapOfInteger

        Return
        -------
        None

        Description
        -----------
        /** * sets this map to be the result of union (aka addition, fuse, merge, boolean or) operation between two given maps. * the new map contains the values that are contained either in the first map or in the second map or in both. * all previous contents of this map is cleared. this map (result of the boolean operation) can also be passed as one of operands. */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Union(self, *args)

    def Unite(self, *args):
        r"""

        Parameters
        ----------
        &: TColStd_PackedMapOfInteger

        Return
        -------
        bool

        Description
        -----------
        /** * apply to this map the boolean operation union (aka addition, fuse, merge, boolean or) with another (given) map. * the result contains the values that were previously contained in this map or contained in the given (operand) map. * this algorithm is similar to method union(). * return true if content of this map is changed */.

        """
        return _TColStd.TColStd_PackedMapOfInteger_Unite(self, *args)

    def __isub_wrapper__(self, other):
        r"""__isub_wrapper__(TColStd_PackedMapOfInteger self, TColStd_PackedMapOfInteger other)"""
        return _TColStd.TColStd_PackedMapOfInteger___isub_wrapper__(self, other)

    def __isub__(self, right):
        self.__isub_wrapper__(right)
        return self


    def __eq_wrapper__(self, other):
        r"""__eq_wrapper__(TColStd_PackedMapOfInteger self, TColStd_PackedMapOfInteger other) -> bool"""
        return _TColStd.TColStd_PackedMapOfInteger___eq_wrapper__(self, other)

    def __eq__(self, right):
        try:
            return self.__eq_wrapper__(right)
        except:
            return False


    __repr__ = _dumps_object

    __swig_destroy__ = _TColStd.delete_TColStd_PackedMapOfInteger

# Register TColStd_PackedMapOfInteger in _TColStd:
_TColStd.TColStd_PackedMapOfInteger_swigregister(TColStd_PackedMapOfInteger)
class TColStd_HArray1OfAsciiString(TColStd_Array1OfAsciiString, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray1OfAsciiString_swiginit(self, _TColStd.new_TColStd_HArray1OfAsciiString(*args))

    def Array1(self):
        return _TColStd.TColStd_HArray1OfAsciiString_Array1(self)

    def ChangeArray1(self):
        return _TColStd.TColStd_HArray1OfAsciiString_ChangeArray1(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray1OfAsciiString_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfAsciiString

# Register TColStd_HArray1OfAsciiString in _TColStd:
_TColStd.TColStd_HArray1OfAsciiString_swigregister(TColStd_HArray1OfAsciiString)
class TColStd_HArray1OfByte(TColStd_Array1OfByte, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray1OfByte_swiginit(self, _TColStd.new_TColStd_HArray1OfByte(*args))

    def Array1(self):
        return _TColStd.TColStd_HArray1OfByte_Array1(self)

    def ChangeArray1(self):
        return _TColStd.TColStd_HArray1OfByte_ChangeArray1(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray1OfByte_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfByte

# Register TColStd_HArray1OfByte in _TColStd:
_TColStd.TColStd_HArray1OfByte_swigregister(TColStd_HArray1OfByte)
class TColStd_HArray1OfInteger(TColStd_Array1OfInteger, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray1OfInteger_swiginit(self, _TColStd.new_TColStd_HArray1OfInteger(*args))

    def Array1(self):
        return _TColStd.TColStd_HArray1OfInteger_Array1(self)

    def ChangeArray1(self):
        return _TColStd.TColStd_HArray1OfInteger_ChangeArray1(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray1OfInteger_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfInteger

# Register TColStd_HArray1OfInteger in _TColStd:
_TColStd.TColStd_HArray1OfInteger_swigregister(TColStd_HArray1OfInteger)
class TColStd_HArray1OfBoolean(TColStd_Array1OfBoolean, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray1OfBoolean_swiginit(self, _TColStd.new_TColStd_HArray1OfBoolean(*args))

    def Array1(self):
        return _TColStd.TColStd_HArray1OfBoolean_Array1(self)

    def ChangeArray1(self):
        return _TColStd.TColStd_HArray1OfBoolean_ChangeArray1(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray1OfBoolean_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfBoolean

# Register TColStd_HArray1OfBoolean in _TColStd:
_TColStd.TColStd_HArray1OfBoolean_swigregister(TColStd_HArray1OfBoolean)
class TColStd_HArray1OfListOfInteger(TColStd_Array1OfListOfInteger, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray1OfListOfInteger_swiginit(self, _TColStd.new_TColStd_HArray1OfListOfInteger(*args))

    def Array1(self):
        return _TColStd.TColStd_HArray1OfListOfInteger_Array1(self)

    def ChangeArray1(self):
        return _TColStd.TColStd_HArray1OfListOfInteger_ChangeArray1(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray1OfListOfInteger_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfListOfInteger

# Register TColStd_HArray1OfListOfInteger in _TColStd:
_TColStd.TColStd_HArray1OfListOfInteger_swigregister(TColStd_HArray1OfListOfInteger)
class TColStd_HArray1OfTransient(TColStd_Array1OfTransient, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray1OfTransient_swiginit(self, _TColStd.new_TColStd_HArray1OfTransient(*args))

    def Array1(self):
        return _TColStd.TColStd_HArray1OfTransient_Array1(self)

    def ChangeArray1(self):
        return _TColStd.TColStd_HArray1OfTransient_ChangeArray1(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray1OfTransient_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfTransient

# Register TColStd_HArray1OfTransient in _TColStd:
_TColStd.TColStd_HArray1OfTransient_swigregister(TColStd_HArray1OfTransient)
class TColStd_HArray1OfCharacter(TColStd_Array1OfCharacter, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray1OfCharacter_swiginit(self, _TColStd.new_TColStd_HArray1OfCharacter(*args))

    def Array1(self):
        return _TColStd.TColStd_HArray1OfCharacter_Array1(self)

    def ChangeArray1(self):
        return _TColStd.TColStd_HArray1OfCharacter_ChangeArray1(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray1OfCharacter_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfCharacter

# Register TColStd_HArray1OfCharacter in _TColStd:
_TColStd.TColStd_HArray1OfCharacter_swigregister(TColStd_HArray1OfCharacter)
class TColStd_HArray1OfExtendedString(TColStd_Array1OfExtendedString, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray1OfExtendedString_swiginit(self, _TColStd.new_TColStd_HArray1OfExtendedString(*args))

    def Array1(self):
        return _TColStd.TColStd_HArray1OfExtendedString_Array1(self)

    def ChangeArray1(self):
        return _TColStd.TColStd_HArray1OfExtendedString_ChangeArray1(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray1OfExtendedString_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfExtendedString

# Register TColStd_HArray1OfExtendedString in _TColStd:
_TColStd.TColStd_HArray1OfExtendedString_swigregister(TColStd_HArray1OfExtendedString)
class TColStd_HArray1OfReal(TColStd_Array1OfReal, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray1OfReal_swiginit(self, _TColStd.new_TColStd_HArray1OfReal(*args))

    def Array1(self):
        return _TColStd.TColStd_HArray1OfReal_Array1(self)

    def ChangeArray1(self):
        return _TColStd.TColStd_HArray1OfReal_ChangeArray1(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray1OfReal_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray1OfReal

# Register TColStd_HArray1OfReal in _TColStd:
_TColStd.TColStd_HArray1OfReal_swigregister(TColStd_HArray1OfReal)
class TColStd_HArray2OfInteger(TColStd_Array2OfInteger, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray2OfInteger_swiginit(self, _TColStd.new_TColStd_HArray2OfInteger(*args))

    def Array2(self):
        return _TColStd.TColStd_HArray2OfInteger_Array2(self)

    def ChangeArray2(self):
        return _TColStd.TColStd_HArray2OfInteger_ChangeArray2(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray2OfInteger_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray2OfInteger

# Register TColStd_HArray2OfInteger in _TColStd:
_TColStd.TColStd_HArray2OfInteger_swigregister(TColStd_HArray2OfInteger)
class TColStd_HArray2OfTransient(TColStd_Array2OfTransient, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray2OfTransient_swiginit(self, _TColStd.new_TColStd_HArray2OfTransient(*args))

    def Array2(self):
        return _TColStd.TColStd_HArray2OfTransient_Array2(self)

    def ChangeArray2(self):
        return _TColStd.TColStd_HArray2OfTransient_ChangeArray2(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray2OfTransient_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray2OfTransient

# Register TColStd_HArray2OfTransient in _TColStd:
_TColStd.TColStd_HArray2OfTransient_swigregister(TColStd_HArray2OfTransient)
class TColStd_HArray2OfBoolean(TColStd_Array2OfBoolean, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray2OfBoolean_swiginit(self, _TColStd.new_TColStd_HArray2OfBoolean(*args))

    def Array2(self):
        return _TColStd.TColStd_HArray2OfBoolean_Array2(self)

    def ChangeArray2(self):
        return _TColStd.TColStd_HArray2OfBoolean_ChangeArray2(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray2OfBoolean_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray2OfBoolean

# Register TColStd_HArray2OfBoolean in _TColStd:
_TColStd.TColStd_HArray2OfBoolean_swigregister(TColStd_HArray2OfBoolean)
class TColStd_HArray2OfReal(TColStd_Array2OfReal, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray2OfReal_swiginit(self, _TColStd.new_TColStd_HArray2OfReal(*args))

    def Array2(self):
        return _TColStd.TColStd_HArray2OfReal_Array2(self)

    def ChangeArray2(self):
        return _TColStd.TColStd_HArray2OfReal_ChangeArray2(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray2OfReal_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray2OfReal

# Register TColStd_HArray2OfReal in _TColStd:
_TColStd.TColStd_HArray2OfReal_swigregister(TColStd_HArray2OfReal)
class TColStd_HArray2OfCharacter(TColStd_Array2OfCharacter, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HArray2OfCharacter_swiginit(self, _TColStd.new_TColStd_HArray2OfCharacter(*args))

    def Array2(self):
        return _TColStd.TColStd_HArray2OfCharacter_Array2(self)

    def ChangeArray2(self):
        return _TColStd.TColStd_HArray2OfCharacter_ChangeArray2(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HArray2OfCharacter_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HArray2OfCharacter

# Register TColStd_HArray2OfCharacter in _TColStd:
_TColStd.TColStd_HArray2OfCharacter_swigregister(TColStd_HArray2OfCharacter)
class TColStd_HSequenceOfInteger(TColStd_SequenceOfInteger, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HSequenceOfInteger_swiginit(self, _TColStd.new_TColStd_HSequenceOfInteger(*args))

    def Sequence(self):
        return _TColStd.TColStd_HSequenceOfInteger_Sequence(self)

    def Append(self, *args):
        return _TColStd.TColStd_HSequenceOfInteger_Append(self, *args)

    def ChangeSequence(self):
        return _TColStd.TColStd_HSequenceOfInteger_ChangeSequence(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HSequenceOfInteger_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfInteger

# Register TColStd_HSequenceOfInteger in _TColStd:
_TColStd.TColStd_HSequenceOfInteger_swigregister(TColStd_HSequenceOfInteger)
class TColStd_HSequenceOfExtendedString(TColStd_SequenceOfExtendedString, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HSequenceOfExtendedString_swiginit(self, _TColStd.new_TColStd_HSequenceOfExtendedString(*args))

    def Sequence(self):
        return _TColStd.TColStd_HSequenceOfExtendedString_Sequence(self)

    def Append(self, *args):
        return _TColStd.TColStd_HSequenceOfExtendedString_Append(self, *args)

    def ChangeSequence(self):
        return _TColStd.TColStd_HSequenceOfExtendedString_ChangeSequence(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HSequenceOfExtendedString_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfExtendedString

# Register TColStd_HSequenceOfExtendedString in _TColStd:
_TColStd.TColStd_HSequenceOfExtendedString_swigregister(TColStd_HSequenceOfExtendedString)
class TColStd_HSequenceOfTransient(TColStd_SequenceOfTransient, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HSequenceOfTransient_swiginit(self, _TColStd.new_TColStd_HSequenceOfTransient(*args))

    def Sequence(self):
        return _TColStd.TColStd_HSequenceOfTransient_Sequence(self)

    def Append(self, *args):
        return _TColStd.TColStd_HSequenceOfTransient_Append(self, *args)

    def ChangeSequence(self):
        return _TColStd.TColStd_HSequenceOfTransient_ChangeSequence(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HSequenceOfTransient_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfTransient

# Register TColStd_HSequenceOfTransient in _TColStd:
_TColStd.TColStd_HSequenceOfTransient_swigregister(TColStd_HSequenceOfTransient)
class TColStd_HSequenceOfHAsciiString(TColStd_SequenceOfHAsciiString, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HSequenceOfHAsciiString_swiginit(self, _TColStd.new_TColStd_HSequenceOfHAsciiString(*args))

    def Sequence(self):
        return _TColStd.TColStd_HSequenceOfHAsciiString_Sequence(self)

    def Append(self, *args):
        return _TColStd.TColStd_HSequenceOfHAsciiString_Append(self, *args)

    def ChangeSequence(self):
        return _TColStd.TColStd_HSequenceOfHAsciiString_ChangeSequence(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HSequenceOfHAsciiString_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfHAsciiString

# Register TColStd_HSequenceOfHAsciiString in _TColStd:
_TColStd.TColStd_HSequenceOfHAsciiString_swigregister(TColStd_HSequenceOfHAsciiString)
class TColStd_HSequenceOfHExtendedString(TColStd_SequenceOfHExtendedString, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HSequenceOfHExtendedString_swiginit(self, _TColStd.new_TColStd_HSequenceOfHExtendedString(*args))

    def Sequence(self):
        return _TColStd.TColStd_HSequenceOfHExtendedString_Sequence(self)

    def Append(self, *args):
        return _TColStd.TColStd_HSequenceOfHExtendedString_Append(self, *args)

    def ChangeSequence(self):
        return _TColStd.TColStd_HSequenceOfHExtendedString_ChangeSequence(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HSequenceOfHExtendedString_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfHExtendedString

# Register TColStd_HSequenceOfHExtendedString in _TColStd:
_TColStd.TColStd_HSequenceOfHExtendedString_swigregister(TColStd_HSequenceOfHExtendedString)
class TColStd_HSequenceOfReal(TColStd_SequenceOfReal, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HSequenceOfReal_swiginit(self, _TColStd.new_TColStd_HSequenceOfReal(*args))

    def Sequence(self):
        return _TColStd.TColStd_HSequenceOfReal_Sequence(self)

    def Append(self, *args):
        return _TColStd.TColStd_HSequenceOfReal_Append(self, *args)

    def ChangeSequence(self):
        return _TColStd.TColStd_HSequenceOfReal_ChangeSequence(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HSequenceOfReal_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfReal

# Register TColStd_HSequenceOfReal in _TColStd:
_TColStd.TColStd_HSequenceOfReal_swigregister(TColStd_HSequenceOfReal)
class TColStd_HSequenceOfAsciiString(TColStd_SequenceOfAsciiString, OCC.Core.Standard.Standard_Transient):
    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):
        _TColStd.TColStd_HSequenceOfAsciiString_swiginit(self, _TColStd.new_TColStd_HSequenceOfAsciiString(*args))

    def Sequence(self):
        return _TColStd.TColStd_HSequenceOfAsciiString_Sequence(self)

    def Append(self, *args):
        return _TColStd.TColStd_HSequenceOfAsciiString_Append(self, *args)

    def ChangeSequence(self):
        return _TColStd.TColStd_HSequenceOfAsciiString_ChangeSequence(self)


    @staticmethod
    def DownCast(t):
      return Handle_TColStd_HSequenceOfAsciiString_DownCast(t)

    __swig_destroy__ = _TColStd.delete_TColStd_HSequenceOfAsciiString

# Register TColStd_HSequenceOfAsciiString in _TColStd:
_TColStd.TColStd_HSequenceOfAsciiString_swigregister(TColStd_HSequenceOfAsciiString)



