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

"""
Module to load an calculation schema from a XML file.
"""

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

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

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

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

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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class loader_PySwigIterator(_object):
    """Proxy of C++ swig::loader_PySwigIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, loader_PySwigIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, loader_PySwigIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _loader.delete_loader_PySwigIterator
    __del__ = lambda self : None;
    def value(self):
        """value(self) -> PyObject"""
        return _loader.loader_PySwigIterator_value(self)

    def incr(self, n = 1):
        """
        incr(self, size_t n = 1) -> loader_PySwigIterator
        incr(self) -> loader_PySwigIterator
        """
        return _loader.loader_PySwigIterator_incr(self, n)

    def decr(self, n = 1):
        """
        decr(self, size_t n = 1) -> loader_PySwigIterator
        decr(self) -> loader_PySwigIterator
        """
        return _loader.loader_PySwigIterator_decr(self, n)

    def distance(self, *args):
        """distance(self, loader_PySwigIterator x) -> ptrdiff_t"""
        return _loader.loader_PySwigIterator_distance(self, *args)

    def equal(self, *args):
        """equal(self, loader_PySwigIterator x) -> bool"""
        return _loader.loader_PySwigIterator_equal(self, *args)

    def copy(self):
        """copy(self) -> loader_PySwigIterator"""
        return _loader.loader_PySwigIterator_copy(self)

    def next(self):
        """next(self) -> PyObject"""
        return _loader.loader_PySwigIterator_next(self)

    def __next__(self):
        """__next__(self) -> PyObject"""
        return _loader.loader_PySwigIterator___next__(self)

    def previous(self):
        """previous(self) -> PyObject"""
        return _loader.loader_PySwigIterator_previous(self)

    def advance(self, *args):
        """advance(self, ptrdiff_t n) -> loader_PySwigIterator"""
        return _loader.loader_PySwigIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(self, loader_PySwigIterator x) -> bool"""
        return _loader.loader_PySwigIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, loader_PySwigIterator x) -> bool"""
        return _loader.loader_PySwigIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, ptrdiff_t n) -> loader_PySwigIterator"""
        return _loader.loader_PySwigIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, ptrdiff_t n) -> loader_PySwigIterator"""
        return _loader.loader_PySwigIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(self, ptrdiff_t n) -> loader_PySwigIterator"""
        return _loader.loader_PySwigIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, ptrdiff_t n) -> loader_PySwigIterator
        __sub__(self, loader_PySwigIterator x) -> ptrdiff_t
        """
        return _loader.loader_PySwigIterator___sub__(self, *args)

    def __iter__(self): return self
loader_PySwigIterator_swigregister = _loader.loader_PySwigIterator_swigregister
loader_PySwigIterator_swigregister(loader_PySwigIterator)

import pilot
class YACSLoader(_object):
    """Proxy of C++ YACS::YACSLoader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, YACSLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, YACSLoader, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> YACSLoader"""
        this = _loader.new_YACSLoader()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _loader.delete_YACSLoader
    __del__ = lambda self : None;
    def load(self, *args):
        """load(self, char filename) -> Proc"""
        return _loader.YACSLoader_load(self, *args)

    def registerProcCataLoader(self):
        """registerProcCataLoader(self)"""
        return _loader.YACSLoader_registerProcCataLoader(self)

YACSLoader_swigregister = _loader.YACSLoader_swigregister
YACSLoader_swigregister(YACSLoader)


def loadState(*args):
  """loadState(Proc p, string xmlStateFile)"""
  return _loader.loadState(*args)
class stateLoader(_object):
    """Proxy of C++ YACS::ENGINE::stateLoader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, stateLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, stateLoader, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, xmlParserBase parser, Proc p) -> stateLoader"""
        this = _loader.new_stateLoader(*args)
        try: self.this.append(this)
        except: self.this = this
    def parse(self, *args):
        """parse(self, string xmlState)"""
        return _loader.stateLoader_parse(self, *args)

    __swig_destroy__ = _loader.delete_stateLoader
    __del__ = lambda self : None;
stateLoader_swigregister = _loader.stateLoader_swigregister
stateLoader_swigregister(stateLoader)

XMLNOCONTEXT = _loader.XMLNOCONTEXT
XMLINGRAPH = _loader.XMLINGRAPH
XMLINNODE = _loader.XMLINNODE
XMLINPORT = _loader.XMLINPORT
XMLINVALUE = _loader.XMLINVALUE
XMLDONE = _loader.XMLDONE
XMLFATALERROR = _loader.XMLFATALERROR
class stateParser(_object):
    """Proxy of C++ YACS::ENGINE::stateParser class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, stateParser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, stateParser, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_state"] = _loader.stateParser__state_set
    __swig_getmethods__["_state"] = _loader.stateParser__state_get
    if _newclass:_state = _swig_property(_loader.stateParser__state_get, _loader.stateParser__state_set)
    __swig_setmethods__["_what"] = _loader.stateParser__what_set
    __swig_getmethods__["_what"] = _loader.stateParser__what_get
    if _newclass:_what = _swig_property(_loader.stateParser__what_get, _loader.stateParser__what_set)
    def setProc(*args):
        """setProc(Proc p)"""
        return _loader.stateParser_setProc(*args)

    if _newclass:setProc = staticmethod(setProc)
    __swig_getmethods__["setProc"] = lambda x: setProc
    def setRuntime(*args):
        """setRuntime(Runtime runtime)"""
        return _loader.stateParser_setRuntime(*args)

    if _newclass:setRuntime = staticmethod(setRuntime)
    __swig_getmethods__["setRuntime"] = lambda x: setRuntime
    def init(self, *args):
        """
        init(self, XML_Char p, xmlParserBase father = None)
        init(self, XML_Char p)
        """
        return _loader.stateParser_init(self, *args)

    def __init__(self): 
        """__init__(self) -> stateParser"""
        this = _loader.new_stateParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _loader.delete_stateParser
    __del__ = lambda self : None;
stateParser_swigregister = _loader.stateParser_swigregister
stateParser_swigregister(stateParser)
cvar = _loader.cvar

def stateParser_setProc(*args):
  """stateParser_setProc(Proc p)"""
  return _loader.stateParser_setProc(*args)

def stateParser_setRuntime(*args):
  """stateParser_setRuntime(Runtime runtime)"""
  return _loader.stateParser_setRuntime(*args)

class graphParser(stateParser):
    """Proxy of C++ YACS::ENGINE::graphParser class"""
    __swig_setmethods__ = {}
    for _s in [stateParser]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, graphParser, name, value)
    __swig_getmethods__ = {}
    for _s in [stateParser]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, graphParser, name)
    __repr__ = _swig_repr
    def init(self, *args):
        """
        init(self, XML_Char p, xmlParserBase father = None)
        init(self, XML_Char p)
        """
        return _loader.graphParser_init(self, *args)

    def onStart(self, *args):
        """onStart(self, XML_Char elem, XML_Char p)"""
        return _loader.graphParser_onStart(self, *args)

    def onEnd(self, *args):
        """onEnd(self, XML_Char name)"""
        return _loader.graphParser_onEnd(self, *args)

    def __init__(self): 
        """__init__(self) -> graphParser"""
        this = _loader.new_graphParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _loader.delete_graphParser
    __del__ = lambda self : None;
graphParser_swigregister = _loader.graphParser_swigregister
graphParser_swigregister(graphParser)

class nodeParser(stateParser):
    """Proxy of C++ YACS::ENGINE::nodeParser class"""
    __swig_setmethods__ = {}
    for _s in [stateParser]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, nodeParser, name, value)
    __swig_getmethods__ = {}
    for _s in [stateParser]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, nodeParser, name)
    __repr__ = _swig_repr
    def init(self, *args):
        """
        init(self, XML_Char p, xmlParserBase father = None)
        init(self, XML_Char p)
        """
        return _loader.nodeParser_init(self, *args)

    def onStart(self, *args):
        """onStart(self, XML_Char elem, XML_Char p)"""
        return _loader.nodeParser_onStart(self, *args)

    def onEnd(self, *args):
        """onEnd(self, XML_Char name)"""
        return _loader.nodeParser_onEnd(self, *args)

    __swig_setmethods__["_nodeName"] = _loader.nodeParser__nodeName_set
    __swig_getmethods__["_nodeName"] = _loader.nodeParser__nodeName_get
    if _newclass:_nodeName = _swig_property(_loader.nodeParser__nodeName_get, _loader.nodeParser__nodeName_set)
    __swig_setmethods__["_nodeState"] = _loader.nodeParser__nodeState_set
    __swig_getmethods__["_nodeState"] = _loader.nodeParser__nodeState_get
    if _newclass:_nodeState = _swig_property(_loader.nodeParser__nodeState_get, _loader.nodeParser__nodeState_set)
    def __init__(self): 
        """__init__(self) -> nodeParser"""
        this = _loader.new_nodeParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _loader.delete_nodeParser
    __del__ = lambda self : None;
nodeParser_swigregister = _loader.nodeParser_swigregister
nodeParser_swigregister(nodeParser)

class attrParser(stateParser):
    """Proxy of C++ YACS::ENGINE::attrParser class"""
    __swig_setmethods__ = {}
    for _s in [stateParser]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, attrParser, name, value)
    __swig_getmethods__ = {}
    for _s in [stateParser]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, attrParser, name)
    __repr__ = _swig_repr
    def init(self, *args):
        """
        init(self, XML_Char p, xmlParserBase father = None)
        init(self, XML_Char p)
        """
        return _loader.attrParser_init(self, *args)

    def onStart(self, *args):
        """onStart(self, XML_Char elem, XML_Char p)"""
        return _loader.attrParser_onStart(self, *args)

    def charData(self, *args):
        """charData(self, string data)"""
        return _loader.attrParser_charData(self, *args)

    def onEnd(self, *args):
        """onEnd(self, XML_Char name)"""
        return _loader.attrParser_onEnd(self, *args)

    __swig_setmethods__["_attrValue"] = _loader.attrParser__attrValue_set
    __swig_getmethods__["_attrValue"] = _loader.attrParser__attrValue_get
    if _newclass:_attrValue = _swig_property(_loader.attrParser__attrValue_get, _loader.attrParser__attrValue_set)
    def __init__(self): 
        """__init__(self) -> attrParser"""
        this = _loader.new_attrParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _loader.delete_attrParser
    __del__ = lambda self : None;
attrParser_swigregister = _loader.attrParser_swigregister
attrParser_swigregister(attrParser)

class portParser(stateParser):
    """Proxy of C++ YACS::ENGINE::portParser class"""
    __swig_setmethods__ = {}
    for _s in [stateParser]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, portParser, name, value)
    __swig_getmethods__ = {}
    for _s in [stateParser]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, portParser, name)
    __repr__ = _swig_repr
    def init(self, *args):
        """
        init(self, XML_Char p, xmlParserBase father = None)
        init(self, XML_Char p)
        """
        return _loader.portParser_init(self, *args)

    def onStart(self, *args):
        """onStart(self, XML_Char elem, XML_Char p)"""
        return _loader.portParser_onStart(self, *args)

    def onEnd(self, *args):
        """onEnd(self, XML_Char name)"""
        return _loader.portParser_onEnd(self, *args)

    def addData(self, *args):
        """addData(self, string value)"""
        return _loader.portParser_addData(self, *args)

    def __init__(self): 
        """__init__(self) -> portParser"""
        this = _loader.new_portParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _loader.delete_portParser
    __del__ = lambda self : None;
portParser_swigregister = _loader.portParser_swigregister
portParser_swigregister(portParser)

class valueParser(stateParser):
    """Proxy of C++ YACS::ENGINE::valueParser class"""
    __swig_setmethods__ = {}
    for _s in [stateParser]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, valueParser, name, value)
    __swig_getmethods__ = {}
    for _s in [stateParser]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, valueParser, name)
    __repr__ = _swig_repr
    def init(self, *args):
        """
        init(self, XML_Char p, xmlParserBase father = None)
        init(self, XML_Char p)
        """
        return _loader.valueParser_init(self, *args)

    def onStart(self, *args):
        """onStart(self, XML_Char elem, XML_Char p)"""
        return _loader.valueParser_onStart(self, *args)

    def onEnd(self, *args):
        """onEnd(self, XML_Char name)"""
        return _loader.valueParser_onEnd(self, *args)

    def addData(self, *args):
        """addData(self, string value)"""
        return _loader.valueParser_addData(self, *args)

    def __init__(self): 
        """__init__(self) -> valueParser"""
        this = _loader.new_valueParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _loader.delete_valueParser
    __del__ = lambda self : None;
valueParser_swigregister = _loader.valueParser_swigregister
valueParser_swigregister(valueParser)

class arrayParser(stateParser):
    """Proxy of C++ YACS::ENGINE::arrayParser class"""
    __swig_setmethods__ = {}
    for _s in [stateParser]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, arrayParser, name, value)
    __swig_getmethods__ = {}
    for _s in [stateParser]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, arrayParser, name)
    __repr__ = _swig_repr
    def init(self, *args):
        """
        init(self, XML_Char p, xmlParserBase father = None)
        init(self, XML_Char p)
        """
        return _loader.arrayParser_init(self, *args)

    def onStart(self, *args):
        """onStart(self, XML_Char elem, XML_Char p)"""
        return _loader.arrayParser_onStart(self, *args)

    def onEnd(self, *args):
        """onEnd(self, XML_Char name)"""
        return _loader.arrayParser_onEnd(self, *args)

    def addData(self, *args):
        """addData(self, string value)"""
        return _loader.arrayParser_addData(self, *args)

    def __init__(self): 
        """__init__(self) -> arrayParser"""
        this = _loader.new_arrayParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _loader.delete_arrayParser
    __del__ = lambda self : None;
arrayParser_swigregister = _loader.arrayParser_swigregister
arrayParser_swigregister(arrayParser)

class dataParser(stateParser):
    """Proxy of C++ YACS::ENGINE::dataParser class"""
    __swig_setmethods__ = {}
    for _s in [stateParser]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, dataParser, name, value)
    __swig_getmethods__ = {}
    for _s in [stateParser]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, dataParser, name)
    __repr__ = _swig_repr
    def init(self, *args):
        """
        init(self, XML_Char p, xmlParserBase father = None)
        init(self, XML_Char p)
        """
        return _loader.dataParser_init(self, *args)

    def onStart(self, *args):
        """onStart(self, XML_Char elem, XML_Char p)"""
        return _loader.dataParser_onStart(self, *args)

    def onEnd(self, *args):
        """onEnd(self, XML_Char name)"""
        return _loader.dataParser_onEnd(self, *args)

    def addData(self, *args):
        """addData(self, string value)"""
        return _loader.dataParser_addData(self, *args)

    __swig_setmethods__["_dataList"] = _loader.dataParser__dataList_set
    __swig_getmethods__["_dataList"] = _loader.dataParser__dataList_get
    if _newclass:_dataList = _swig_property(_loader.dataParser__dataList_get, _loader.dataParser__dataList_set)
    def __init__(self): 
        """__init__(self) -> dataParser"""
        this = _loader.new_dataParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _loader.delete_dataParser
    __del__ = lambda self : None;
dataParser_swigregister = _loader.dataParser_swigregister
dataParser_swigregister(dataParser)

class simpleTypeParser(stateParser):
    """Proxy of C++ YACS::ENGINE::simpleTypeParser class"""
    __swig_setmethods__ = {}
    for _s in [stateParser]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, simpleTypeParser, name, value)
    __swig_getmethods__ = {}
    for _s in [stateParser]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, simpleTypeParser, name)
    __repr__ = _swig_repr
    def init(self, *args):
        """
        init(self, XML_Char p, xmlParserBase father = None)
        init(self, XML_Char p)
        """
        return _loader.simpleTypeParser_init(self, *args)

    def onStart(self, *args):
        """onStart(self, XML_Char elem, XML_Char p)"""
        return _loader.simpleTypeParser_onStart(self, *args)

    def onEnd(self, *args):
        """onEnd(self, XML_Char name)"""
        return _loader.simpleTypeParser_onEnd(self, *args)

    def charData(self, *args):
        """charData(self, string data)"""
        return _loader.simpleTypeParser_charData(self, *args)

    def __init__(self): 
        """__init__(self) -> simpleTypeParser"""
        this = _loader.new_simpleTypeParser()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _loader.delete_simpleTypeParser
    __del__ = lambda self : None;
simpleTypeParser_swigregister = _loader.simpleTypeParser_swigregister
simpleTypeParser_swigregister(simpleTypeParser)



