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



from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_PMCTuple', [dirname(__file__)])
        except ImportError:
            import _PMCTuple
            return _PMCTuple
        if fp is not None:
            try:
                _mod = imp.load_module('_PMCTuple', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _PMCTuple = swig_import_helper()
    del swig_import_helper
else:
    import _PMCTuple
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

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

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

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


from PMC import *



def pmc_is_tuple0(*args):
  return _PMCTuple.pmc_is_tuple0(*args)
pmc_is_tuple0 = _PMCTuple.pmc_is_tuple0

def pmc_tuple0_get(*args):
  return _PMCTuple.pmc_tuple0_get(*args)
pmc_tuple0_get = _PMCTuple.pmc_tuple0_get

def pmc_tuple0_set(*args):
  return _PMCTuple.pmc_tuple0_set(*args)
pmc_tuple0_set = _PMCTuple.pmc_tuple0_set

def pmc_make_tuple0():
  return _PMCTuple.pmc_make_tuple0()
pmc_make_tuple0 = _PMCTuple.pmc_make_tuple0
def pmc_make_swig_tuple0(elems):
    t = pmc_make_tuple0()
    for i, elem in enumerate(elems):
        pmc_tuple0_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 0,
    py2pmc = pmc_make_swig_tuple0,
)

def pmc_make_py_tuple0(p):
    l = []
    for i in range(0):
        elem = pmc_tuple0_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple0,
    pmc2py = pmc_make_py_tuple0,
)



def pmc_is_tuple1(*args):
  return _PMCTuple.pmc_is_tuple1(*args)
pmc_is_tuple1 = _PMCTuple.pmc_is_tuple1

def pmc_tuple1_get(*args):
  return _PMCTuple.pmc_tuple1_get(*args)
pmc_tuple1_get = _PMCTuple.pmc_tuple1_get

def pmc_tuple1_set(*args):
  return _PMCTuple.pmc_tuple1_set(*args)
pmc_tuple1_set = _PMCTuple.pmc_tuple1_set

def pmc_make_tuple1():
  return _PMCTuple.pmc_make_tuple1()
pmc_make_tuple1 = _PMCTuple.pmc_make_tuple1
def pmc_make_swig_tuple1(elems):
    t = pmc_make_tuple1()
    for i, elem in enumerate(elems):
        pmc_tuple1_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 1,
    py2pmc = pmc_make_swig_tuple1,
)

def pmc_make_py_tuple1(p):
    l = []
    for i in range(1):
        elem = pmc_tuple1_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple1,
    pmc2py = pmc_make_py_tuple1,
)



def pmc_is_tuple2(*args):
  return _PMCTuple.pmc_is_tuple2(*args)
pmc_is_tuple2 = _PMCTuple.pmc_is_tuple2

def pmc_tuple2_get(*args):
  return _PMCTuple.pmc_tuple2_get(*args)
pmc_tuple2_get = _PMCTuple.pmc_tuple2_get

def pmc_tuple2_set(*args):
  return _PMCTuple.pmc_tuple2_set(*args)
pmc_tuple2_set = _PMCTuple.pmc_tuple2_set

def pmc_make_tuple2():
  return _PMCTuple.pmc_make_tuple2()
pmc_make_tuple2 = _PMCTuple.pmc_make_tuple2
def pmc_make_swig_tuple2(elems):
    t = pmc_make_tuple2()
    for i, elem in enumerate(elems):
        pmc_tuple2_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 2,
    py2pmc = pmc_make_swig_tuple2,
)

def pmc_make_py_tuple2(p):
    l = []
    for i in range(2):
        elem = pmc_tuple2_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple2,
    pmc2py = pmc_make_py_tuple2,
)



def pmc_is_tuple3(*args):
  return _PMCTuple.pmc_is_tuple3(*args)
pmc_is_tuple3 = _PMCTuple.pmc_is_tuple3

def pmc_tuple3_get(*args):
  return _PMCTuple.pmc_tuple3_get(*args)
pmc_tuple3_get = _PMCTuple.pmc_tuple3_get

def pmc_tuple3_set(*args):
  return _PMCTuple.pmc_tuple3_set(*args)
pmc_tuple3_set = _PMCTuple.pmc_tuple3_set

def pmc_make_tuple3():
  return _PMCTuple.pmc_make_tuple3()
pmc_make_tuple3 = _PMCTuple.pmc_make_tuple3
def pmc_make_swig_tuple3(elems):
    t = pmc_make_tuple3()
    for i, elem in enumerate(elems):
        pmc_tuple3_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 3,
    py2pmc = pmc_make_swig_tuple3,
)

def pmc_make_py_tuple3(p):
    l = []
    for i in range(3):
        elem = pmc_tuple3_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple3,
    pmc2py = pmc_make_py_tuple3,
)



def pmc_is_tuple4(*args):
  return _PMCTuple.pmc_is_tuple4(*args)
pmc_is_tuple4 = _PMCTuple.pmc_is_tuple4

def pmc_tuple4_get(*args):
  return _PMCTuple.pmc_tuple4_get(*args)
pmc_tuple4_get = _PMCTuple.pmc_tuple4_get

def pmc_tuple4_set(*args):
  return _PMCTuple.pmc_tuple4_set(*args)
pmc_tuple4_set = _PMCTuple.pmc_tuple4_set

def pmc_make_tuple4():
  return _PMCTuple.pmc_make_tuple4()
pmc_make_tuple4 = _PMCTuple.pmc_make_tuple4
def pmc_make_swig_tuple4(elems):
    t = pmc_make_tuple4()
    for i, elem in enumerate(elems):
        pmc_tuple4_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 4,
    py2pmc = pmc_make_swig_tuple4,
)

def pmc_make_py_tuple4(p):
    l = []
    for i in range(4):
        elem = pmc_tuple4_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple4,
    pmc2py = pmc_make_py_tuple4,
)



def pmc_is_tuple5(*args):
  return _PMCTuple.pmc_is_tuple5(*args)
pmc_is_tuple5 = _PMCTuple.pmc_is_tuple5

def pmc_tuple5_get(*args):
  return _PMCTuple.pmc_tuple5_get(*args)
pmc_tuple5_get = _PMCTuple.pmc_tuple5_get

def pmc_tuple5_set(*args):
  return _PMCTuple.pmc_tuple5_set(*args)
pmc_tuple5_set = _PMCTuple.pmc_tuple5_set

def pmc_make_tuple5():
  return _PMCTuple.pmc_make_tuple5()
pmc_make_tuple5 = _PMCTuple.pmc_make_tuple5
def pmc_make_swig_tuple5(elems):
    t = pmc_make_tuple5()
    for i, elem in enumerate(elems):
        pmc_tuple5_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 5,
    py2pmc = pmc_make_swig_tuple5,
)

def pmc_make_py_tuple5(p):
    l = []
    for i in range(5):
        elem = pmc_tuple5_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple5,
    pmc2py = pmc_make_py_tuple5,
)



def pmc_is_tuple6(*args):
  return _PMCTuple.pmc_is_tuple6(*args)
pmc_is_tuple6 = _PMCTuple.pmc_is_tuple6

def pmc_tuple6_get(*args):
  return _PMCTuple.pmc_tuple6_get(*args)
pmc_tuple6_get = _PMCTuple.pmc_tuple6_get

def pmc_tuple6_set(*args):
  return _PMCTuple.pmc_tuple6_set(*args)
pmc_tuple6_set = _PMCTuple.pmc_tuple6_set

def pmc_make_tuple6():
  return _PMCTuple.pmc_make_tuple6()
pmc_make_tuple6 = _PMCTuple.pmc_make_tuple6
def pmc_make_swig_tuple6(elems):
    t = pmc_make_tuple6()
    for i, elem in enumerate(elems):
        pmc_tuple6_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 6,
    py2pmc = pmc_make_swig_tuple6,
)

def pmc_make_py_tuple6(p):
    l = []
    for i in range(6):
        elem = pmc_tuple6_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple6,
    pmc2py = pmc_make_py_tuple6,
)



def pmc_is_tuple7(*args):
  return _PMCTuple.pmc_is_tuple7(*args)
pmc_is_tuple7 = _PMCTuple.pmc_is_tuple7

def pmc_tuple7_get(*args):
  return _PMCTuple.pmc_tuple7_get(*args)
pmc_tuple7_get = _PMCTuple.pmc_tuple7_get

def pmc_tuple7_set(*args):
  return _PMCTuple.pmc_tuple7_set(*args)
pmc_tuple7_set = _PMCTuple.pmc_tuple7_set

def pmc_make_tuple7():
  return _PMCTuple.pmc_make_tuple7()
pmc_make_tuple7 = _PMCTuple.pmc_make_tuple7
def pmc_make_swig_tuple7(elems):
    t = pmc_make_tuple7()
    for i, elem in enumerate(elems):
        pmc_tuple7_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 7,
    py2pmc = pmc_make_swig_tuple7,
)

def pmc_make_py_tuple7(p):
    l = []
    for i in range(7):
        elem = pmc_tuple7_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple7,
    pmc2py = pmc_make_py_tuple7,
)



def pmc_is_tuple8(*args):
  return _PMCTuple.pmc_is_tuple8(*args)
pmc_is_tuple8 = _PMCTuple.pmc_is_tuple8

def pmc_tuple8_get(*args):
  return _PMCTuple.pmc_tuple8_get(*args)
pmc_tuple8_get = _PMCTuple.pmc_tuple8_get

def pmc_tuple8_set(*args):
  return _PMCTuple.pmc_tuple8_set(*args)
pmc_tuple8_set = _PMCTuple.pmc_tuple8_set

def pmc_make_tuple8():
  return _PMCTuple.pmc_make_tuple8()
pmc_make_tuple8 = _PMCTuple.pmc_make_tuple8
def pmc_make_swig_tuple8(elems):
    t = pmc_make_tuple8()
    for i, elem in enumerate(elems):
        pmc_tuple8_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 8,
    py2pmc = pmc_make_swig_tuple8,
)

def pmc_make_py_tuple8(p):
    l = []
    for i in range(8):
        elem = pmc_tuple8_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple8,
    pmc2py = pmc_make_py_tuple8,
)



def pmc_is_tuple9(*args):
  return _PMCTuple.pmc_is_tuple9(*args)
pmc_is_tuple9 = _PMCTuple.pmc_is_tuple9

def pmc_tuple9_get(*args):
  return _PMCTuple.pmc_tuple9_get(*args)
pmc_tuple9_get = _PMCTuple.pmc_tuple9_get

def pmc_tuple9_set(*args):
  return _PMCTuple.pmc_tuple9_set(*args)
pmc_tuple9_set = _PMCTuple.pmc_tuple9_set

def pmc_make_tuple9():
  return _PMCTuple.pmc_make_tuple9()
pmc_make_tuple9 = _PMCTuple.pmc_make_tuple9
def pmc_make_swig_tuple9(elems):
    t = pmc_make_tuple9()
    for i, elem in enumerate(elems):
        pmc_tuple9_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 9,
    py2pmc = pmc_make_swig_tuple9,
)

def pmc_make_py_tuple9(p):
    l = []
    for i in range(9):
        elem = pmc_tuple9_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple9,
    pmc2py = pmc_make_py_tuple9,
)



def pmc_is_tuple10(*args):
  return _PMCTuple.pmc_is_tuple10(*args)
pmc_is_tuple10 = _PMCTuple.pmc_is_tuple10

def pmc_tuple10_get(*args):
  return _PMCTuple.pmc_tuple10_get(*args)
pmc_tuple10_get = _PMCTuple.pmc_tuple10_get

def pmc_tuple10_set(*args):
  return _PMCTuple.pmc_tuple10_set(*args)
pmc_tuple10_set = _PMCTuple.pmc_tuple10_set

def pmc_make_tuple10():
  return _PMCTuple.pmc_make_tuple10()
pmc_make_tuple10 = _PMCTuple.pmc_make_tuple10
def pmc_make_swig_tuple10(elems):
    t = pmc_make_tuple10()
    for i, elem in enumerate(elems):
        pmc_tuple10_set(t, i, Py2PMC(elem))
    return t

RegisterPy2PMC(
    is_py = lambda x: type(x) is tuple and len(x) == 10,
    py2pmc = pmc_make_swig_tuple10,
)

def pmc_make_py_tuple10(p):
    l = []
    for i in range(10):
        elem = pmc_tuple10_get(p, i)
        l.append(PMC2Py(elem))
    return tuple(l)

RegisterPMC2Py(
    is_pmc = pmc_is_tuple10,
    pmc2py = pmc_make_py_tuple10,
)


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


