text: # This file was automatically generated by SWIG (http://www.swig.org).
  # Version 3.0.12
  #
  # 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 as _swig_python_version_info
  if _swig_python_version_info >= (2, 7, 0):
      def swig_import_helper():
          import importlib
          pkg = __name__.rpartition('.')[0]
          mname = '.'.join((pkg, '_eclipse')).lstrip('.')
          try:
              return importlib.import_module(mname)
          except ImportError:
              return importlib.import_module('_eclipse')
      _eclipse = swig_import_helper()
      del swig_import_helper
  elif _swig_python_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('_eclipse', [dirname(__file__)])
          except ImportError:
              import _eclipse
              return _eclipse
          try:
              _mod = imp.load_module('_eclipse', fp, pathname, description)
          finally:
              if fp is not None:
                  fp.close()
          return _mod
      _eclipse = swig_import_helper()
      del swig_import_helper
  else:
      import _eclipse
  del _swig_python_version_info
  
  try:
      _swig_property = property
  except NameError:
      pass  # Python < 2.2 doesn't have 'property'.
  
  try:
      import builtins as __builtin__
  except ImportError:
      import __builtin__
  
  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):
          if _newclass:
              object.__setattr__(self, name, value)
          else:
              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("'%s' object has no attribute '%s'" % (class_type.__name__, name))
  
  
  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,)
  
  try:
      _object = object
      _newclass = 1
  except __builtin__.Exception:
      class _object:
          pass
      _newclass = 0
  
  class SwigPyIterator(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
  
      def __init__(self, *args, **kwargs):
          raise AttributeError("No constructor defined - class is abstract")
      __repr__ = _swig_repr
      __swig_destroy__ = _eclipse.delete_SwigPyIterator
      __del__ = lambda self: None
  
      def value(self):
          return _eclipse.SwigPyIterator_value(self)
  
      def incr(self, n=1):
          return _eclipse.SwigPyIterator_incr(self, n)
  
      def decr(self, n=1):
          return _eclipse.SwigPyIterator_decr(self, n)
  
      def distance(self, x):
          return _eclipse.SwigPyIterator_distance(self, x)
  
      def equal(self, x):
          return _eclipse.SwigPyIterator_equal(self, x)
  
      def copy(self):
          return _eclipse.SwigPyIterator_copy(self)
  
      def next(self):
          return _eclipse.SwigPyIterator_next(self)
  
      def __next__(self):
          return _eclipse.SwigPyIterator___next__(self)
  
      def previous(self):
          return _eclipse.SwigPyIterator_previous(self)
  
      def advance(self, n):
          return _eclipse.SwigPyIterator_advance(self, n)
  
      def __eq__(self, x):
          return _eclipse.SwigPyIterator___eq__(self, x)
  
      def __ne__(self, x):
          return _eclipse.SwigPyIterator___ne__(self, x)
  
      def __iadd__(self, n):
          return _eclipse.SwigPyIterator___iadd__(self, n)
  
      def __isub__(self, n):
          return _eclipse.SwigPyIterator___isub__(self, n)
  
      def __add__(self, n):
          return _eclipse.SwigPyIterator___add__(self, n)
  
      def __sub__(self, *args):
          return _eclipse.SwigPyIterator___sub__(self, *args)
      def __iter__(self):
          return self
  SwigPyIterator_swigregister = _eclipse.SwigPyIterator_swigregister
  SwigPyIterator_swigregister(SwigPyIterator)
  
  
  def new_doubleArray(nelements):
      return _eclipse.new_doubleArray(nelements)
  new_doubleArray = _eclipse.new_doubleArray
  
  def delete_doubleArray(ary):
      return _eclipse.delete_doubleArray(ary)
  delete_doubleArray = _eclipse.delete_doubleArray
  
  def doubleArray_getitem(ary, index):
      return _eclipse.doubleArray_getitem(ary, index)
  doubleArray_getitem = _eclipse.doubleArray_getitem
  
  def doubleArray_setitem(ary, index, value):
      return _eclipse.doubleArray_setitem(ary, index, value)
  doubleArray_setitem = _eclipse.doubleArray_setitem
  
  def new_longArray(nelements):
      return _eclipse.new_longArray(nelements)
  new_longArray = _eclipse.new_longArray
  
  def delete_longArray(ary):
      return _eclipse.delete_longArray(ary)
  delete_longArray = _eclipse.delete_longArray
  
  def longArray_getitem(ary, index):
      return _eclipse.longArray_getitem(ary, index)
  longArray_getitem = _eclipse.longArray_getitem
  
  def longArray_setitem(ary, index, value):
      return _eclipse.longArray_setitem(ary, index, value)
  longArray_setitem = _eclipse.longArray_setitem
  
  def new_intArray(nelements):
      return _eclipse.new_intArray(nelements)
  new_intArray = _eclipse.new_intArray
  
  def delete_intArray(ary):
      return _eclipse.delete_intArray(ary)
  delete_intArray = _eclipse.delete_intArray
  
  def intArray_getitem(ary, index):
      return _eclipse.intArray_getitem(ary, index)
  intArray_getitem = _eclipse.intArray_getitem
  
  def intArray_setitem(ary, index, value):
      return _eclipse.intArray_setitem(ary, index, value)
  intArray_setitem = _eclipse.intArray_setitem
  
  def new_shortArray(nelements):
      return _eclipse.new_shortArray(nelements)
  new_shortArray = _eclipse.new_shortArray
  
  def delete_shortArray(ary):
      return _eclipse.delete_shortArray(ary)
  delete_shortArray = _eclipse.delete_shortArray
  
  def shortArray_getitem(ary, index):
      return _eclipse.shortArray_getitem(ary, index)
  shortArray_getitem = _eclipse.shortArray_getitem
  
  def shortArray_setitem(ary, index, value):
      return _eclipse.shortArray_setitem(ary, index, value)
  shortArray_setitem = _eclipse.shortArray_setitem
  
  
  def getStructSize(self):
      try:
          return eval('sizeof_' + repr(self).split(';')[0].split('.')[-1])
      except (NameError) as e:
          typeString = 'sizeof_' + repr(self).split(';')[0].split('.')[-1]
          raise NameError(e.message + '\nYou tried to get this size macro: ' + typeString + 
              '\n It appears to be undefined.  \nYou need to run the SWIG GEN_SIZEOF' +  
              ' SWIG macro against the class/struct in your SWIG file if you want to ' + 
              ' make this call.\n')
  
  
  def protectSetAttr(self, name, value):
      if(hasattr(self, name) or name == 'this'):
          object.__setattr__(self, name, value)
      else:
          raise ValueError('You tried to add this variable: ' + name + '\n' + 
              'To this class: ' + str(self))
  
  def protectAllClasses(moduleType):
      import inspect
      clsmembers = inspect.getmembers(sys.modules[__name__], inspect.isclass)
      for member in clsmembers:
          try:
              exec(str(member[0]) + '.__setattr__ = protectSetAttr')
              exec(str(member[0]) + '.getStructSize = getStructSize') 
          except (AttributeError, TypeError) as e:
              pass
  
  
  
  def new_boolArray(nelements):
      return _eclipse.new_boolArray(nelements)
  new_boolArray = _eclipse.new_boolArray
  
  def delete_boolArray(ary):
      return _eclipse.delete_boolArray(ary)
  delete_boolArray = _eclipse.delete_boolArray
  
  def boolArray_getitem(ary, index):
      return _eclipse.boolArray_getitem(ary, index)
  boolArray_getitem = _eclipse.boolArray_getitem
  
  def boolArray_setitem(ary, index, value):
      return _eclipse.boolArray_setitem(ary, index, value)
  boolArray_setitem = _eclipse.boolArray_setitem
  class IntVector(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
      __repr__ = _swig_repr
  
      def iterator(self):
          return _eclipse.IntVector_iterator(self)
      def __iter__(self):
          return self.iterator()
  
      def __nonzero__(self):
          return _eclipse.IntVector___nonzero__(self)
  
      def __bool__(self):
          return _eclipse.IntVector___bool__(self)
  
      def __len__(self):
          return _eclipse.IntVector___len__(self)
  
      def __getslice__(self, i, j):
          return _eclipse.IntVector___getslice__(self, i, j)
  
      def __setslice__(self, *args):
          return _eclipse.IntVector___setslice__(self, *args)
  
      def __delslice__(self, i, j):
          return _eclipse.IntVector___delslice__(self, i, j)
  
      def __delitem__(self, *args):
          return _eclipse.IntVector___delitem__(self, *args)
  
      def __getitem__(self, *args):
          return _eclipse.IntVector___getitem__(self, *args)
  
      def __setitem__(self, *args):
          return _eclipse.IntVector___setitem__(self, *args)
  
      def pop(self):
          return _eclipse.IntVector_pop(self)
  
      def append(self, x):
          return _eclipse.IntVector_append(self, x)
  
      def empty(self):
          return _eclipse.IntVector_empty(self)
  
      def size(self):
          return _eclipse.IntVector_size(self)
  
      def swap(self, v):
          return _eclipse.IntVector_swap(self, v)
  
      def begin(self):
          return _eclipse.IntVector_begin(self)
  
      def end(self):
          return _eclipse.IntVector_end(self)
  
      def rbegin(self):
          return _eclipse.IntVector_rbegin(self)
  
      def rend(self):
          return _eclipse.IntVector_rend(self)
  
      def clear(self):
          return _eclipse.IntVector_clear(self)
  
      def get_allocator(self):
          return _eclipse.IntVector_get_allocator(self)
  
      def pop_back(self):
          return _eclipse.IntVector_pop_back(self)
  
      def erase(self, *args):
          return _eclipse.IntVector_erase(self, *args)
  
      def __init__(self, *args):
          this = _eclipse.new_IntVector(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
  
      def push_back(self, x):
          return _eclipse.IntVector_push_back(self, x)
  
      def front(self):
          return _eclipse.IntVector_front(self)
  
      def back(self):
          return _eclipse.IntVector_back(self)
  
      def assign(self, n, x):
          return _eclipse.IntVector_assign(self, n, x)
  
      def resize(self, *args):
          return _eclipse.IntVector_resize(self, *args)
  
      def insert(self, *args):
          return _eclipse.IntVector_insert(self, *args)
  
      def reserve(self, n):
          return _eclipse.IntVector_reserve(self, n)
  
      def capacity(self):
          return _eclipse.IntVector_capacity(self)
      __swig_destroy__ = _eclipse.delete_IntVector
      __del__ = lambda self: None
  IntVector_swigregister = _eclipse.IntVector_swigregister
  IntVector_swigregister(IntVector)
  
  class DoubleVector(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
      __repr__ = _swig_repr
  
      def iterator(self):
          return _eclipse.DoubleVector_iterator(self)
      def __iter__(self):
          return self.iterator()
  
      def __nonzero__(self):
          return _eclipse.DoubleVector___nonzero__(self)
  
      def __bool__(self):
          return _eclipse.DoubleVector___bool__(self)
  
      def __len__(self):
          return _eclipse.DoubleVector___len__(self)
  
      def __getslice__(self, i, j):
          return _eclipse.DoubleVector___getslice__(self, i, j)
  
      def __setslice__(self, *args):
          return _eclipse.DoubleVector___setslice__(self, *args)
  
      def __delslice__(self, i, j):
          return _eclipse.DoubleVector___delslice__(self, i, j)
  
      def __delitem__(self, *args):
          return _eclipse.DoubleVector___delitem__(self, *args)
  
      def __getitem__(self, *args):
          return _eclipse.DoubleVector___getitem__(self, *args)
  
      def __setitem__(self, *args):
          return _eclipse.DoubleVector___setitem__(self, *args)
  
      def pop(self):
          return _eclipse.DoubleVector_pop(self)
  
      def append(self, x):
          return _eclipse.DoubleVector_append(self, x)
  
      def empty(self):
          return _eclipse.DoubleVector_empty(self)
  
      def size(self):
          return _eclipse.DoubleVector_size(self)
  
      def swap(self, v):
          return _eclipse.DoubleVector_swap(self, v)
  
      def begin(self):
          return _eclipse.DoubleVector_begin(self)
  
      def end(self):
          return _eclipse.DoubleVector_end(self)
  
      def rbegin(self):
          return _eclipse.DoubleVector_rbegin(self)
  
      def rend(self):
          return _eclipse.DoubleVector_rend(self)
  
      def clear(self):
          return _eclipse.DoubleVector_clear(self)
  
      def get_allocator(self):
          return _eclipse.DoubleVector_get_allocator(self)
  
      def pop_back(self):
          return _eclipse.DoubleVector_pop_back(self)
  
      def erase(self, *args):
          return _eclipse.DoubleVector_erase(self, *args)
  
      def __init__(self, *args):
          this = _eclipse.new_DoubleVector(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
  
      def push_back(self, x):
          return _eclipse.DoubleVector_push_back(self, x)
  
      def front(self):
          return _eclipse.DoubleVector_front(self)
  
      def back(self):
          return _eclipse.DoubleVector_back(self)
  
      def assign(self, n, x):
          return _eclipse.DoubleVector_assign(self, n, x)
  
      def resize(self, *args):
          return _eclipse.DoubleVector_resize(self, *args)
  
      def insert(self, *args):
          return _eclipse.DoubleVector_insert(self, *args)
  
      def reserve(self, n):
          return _eclipse.DoubleVector_reserve(self, n)
  
      def capacity(self):
          return _eclipse.DoubleVector_capacity(self)
      __swig_destroy__ = _eclipse.delete_DoubleVector
      __del__ = lambda self: None
  DoubleVector_swigregister = _eclipse.DoubleVector_swigregister
  DoubleVector_swigregister(DoubleVector)
  
  class StringVector(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
      __repr__ = _swig_repr
  
      def iterator(self):
          return _eclipse.StringVector_iterator(self)
      def __iter__(self):
          return self.iterator()
  
      def __nonzero__(self):
          return _eclipse.StringVector___nonzero__(self)
  
      def __bool__(self):
          return _eclipse.StringVector___bool__(self)
  
      def __len__(self):
          return _eclipse.StringVector___len__(self)
  
      def __getslice__(self, i, j):
          return _eclipse.StringVector___getslice__(self, i, j)
  
      def __setslice__(self, *args):
          return _eclipse.StringVector___setslice__(self, *args)
  
      def __delslice__(self, i, j):
          return _eclipse.StringVector___delslice__(self, i, j)
  
      def __delitem__(self, *args):
          return _eclipse.StringVector___delitem__(self, *args)
  
      def __getitem__(self, *args):
          return _eclipse.StringVector___getitem__(self, *args)
  
      def __setitem__(self, *args):
          return _eclipse.StringVector___setitem__(self, *args)
  
      def pop(self):
          return _eclipse.StringVector_pop(self)
  
      def append(self, x):
          return _eclipse.StringVector_append(self, x)
  
      def empty(self):
          return _eclipse.StringVector_empty(self)
  
      def size(self):
          return _eclipse.StringVector_size(self)
  
      def swap(self, v):
          return _eclipse.StringVector_swap(self, v)
  
      def begin(self):
          return _eclipse.StringVector_begin(self)
  
      def end(self):
          return _eclipse.StringVector_end(self)
  
      def rbegin(self):
          return _eclipse.StringVector_rbegin(self)
  
      def rend(self):
          return _eclipse.StringVector_rend(self)
  
      def clear(self):
          return _eclipse.StringVector_clear(self)
  
      def get_allocator(self):
          return _eclipse.StringVector_get_allocator(self)
  
      def pop_back(self):
          return _eclipse.StringVector_pop_back(self)
  
      def erase(self, *args):
          return _eclipse.StringVector_erase(self, *args)
  
      def __init__(self, *args):
          this = _eclipse.new_StringVector(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
  
      def push_back(self, x):
          return _eclipse.StringVector_push_back(self, x)
  
      def front(self):
          return _eclipse.StringVector_front(self)
  
      def back(self):
          return _eclipse.StringVector_back(self)
  
      def assign(self, n, x):
          return _eclipse.StringVector_assign(self, n, x)
  
      def resize(self, *args):
          return _eclipse.StringVector_resize(self, *args)
  
      def insert(self, *args):
          return _eclipse.StringVector_insert(self, *args)
  
      def reserve(self, n):
          return _eclipse.StringVector_reserve(self, n)
  
      def capacity(self):
          return _eclipse.StringVector_capacity(self)
      __swig_destroy__ = _eclipse.delete_StringVector
      __del__ = lambda self: None
  StringVector_swigregister = _eclipse.StringVector_swigregister
  StringVector_swigregister(StringVector)
  
  class StringSet(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, StringSet, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, StringSet, name)
      __repr__ = _swig_repr
  
      def iterator(self):
          return _eclipse.StringSet_iterator(self)
      def __iter__(self):
          return self.iterator()
  
      def __nonzero__(self):
          return _eclipse.StringSet___nonzero__(self)
  
      def __bool__(self):
          return _eclipse.StringSet___bool__(self)
  
      def __len__(self):
          return _eclipse.StringSet___len__(self)
  
      def append(self, x):
          return _eclipse.StringSet_append(self, x)
  
      def __contains__(self, x):
          return _eclipse.StringSet___contains__(self, x)
  
      def __getitem__(self, i):
          return _eclipse.StringSet___getitem__(self, i)
  
      def add(self, x):
          return _eclipse.StringSet_add(self, x)
  
      def discard(self, x):
          return _eclipse.StringSet_discard(self, x)
  
      def __init__(self, *args):
          this = _eclipse.new_StringSet(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
  
      def empty(self):
          return _eclipse.StringSet_empty(self)
  
      def size(self):
          return _eclipse.StringSet_size(self)
  
      def clear(self):
          return _eclipse.StringSet_clear(self)
  
      def swap(self, v):
          return _eclipse.StringSet_swap(self, v)
  
      def count(self, x):
          return _eclipse.StringSet_count(self, x)
  
      def begin(self):
          return _eclipse.StringSet_begin(self)
  
      def end(self):
          return _eclipse.StringSet_end(self)
  
      def rbegin(self):
          return _eclipse.StringSet_rbegin(self)
  
      def rend(self):
          return _eclipse.StringSet_rend(self)
  
      def erase(self, *args):
          return _eclipse.StringSet_erase(self, *args)
  
      def find(self, x):
          return _eclipse.StringSet_find(self, x)
  
      def lower_bound(self, x):
          return _eclipse.StringSet_lower_bound(self, x)
  
      def upper_bound(self, x):
          return _eclipse.StringSet_upper_bound(self, x)
  
      def equal_range(self, x):
          return _eclipse.StringSet_equal_range(self, x)
  
      def insert(self, __x):
          return _eclipse.StringSet_insert(self, __x)
      __swig_destroy__ = _eclipse.delete_StringSet
      __del__ = lambda self: None
  StringSet_swigregister = _eclipse.StringSet_swigregister
  StringSet_swigregister(StringSet)
  
  class intSet(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, intSet, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, intSet, name)
      __repr__ = _swig_repr
  
      def iterator(self):
          return _eclipse.intSet_iterator(self)
      def __iter__(self):
          return self.iterator()
  
      def __nonzero__(self):
          return _eclipse.intSet___nonzero__(self)
  
      def __bool__(self):
          return _eclipse.intSet___bool__(self)
  
      def __len__(self):
          return _eclipse.intSet___len__(self)
  
      def append(self, x):
          return _eclipse.intSet_append(self, x)
  
      def __contains__(self, x):
          return _eclipse.intSet___contains__(self, x)
  
      def __getitem__(self, i):
          return _eclipse.intSet___getitem__(self, i)
  
      def add(self, x):
          return _eclipse.intSet_add(self, x)
  
      def discard(self, x):
          return _eclipse.intSet_discard(self, x)
  
      def __init__(self, *args):
          this = _eclipse.new_intSet(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
  
      def empty(self):
          return _eclipse.intSet_empty(self)
  
      def size(self):
          return _eclipse.intSet_size(self)
  
      def clear(self):
          return _eclipse.intSet_clear(self)
  
      def swap(self, v):
          return _eclipse.intSet_swap(self, v)
  
      def count(self, x):
          return _eclipse.intSet_count(self, x)
  
      def begin(self):
          return _eclipse.intSet_begin(self)
  
      def end(self):
          return _eclipse.intSet_end(self)
  
      def rbegin(self):
          return _eclipse.intSet_rbegin(self)
  
      def rend(self):
          return _eclipse.intSet_rend(self)
  
      def erase(self, *args):
          return _eclipse.intSet_erase(self, *args)
  
      def find(self, x):
          return _eclipse.intSet_find(self, x)
  
      def lower_bound(self, x):
          return _eclipse.intSet_lower_bound(self, x)
  
      def upper_bound(self, x):
          return _eclipse.intSet_upper_bound(self, x)
  
      def equal_range(self, x):
          return _eclipse.intSet_equal_range(self, x)
  
      def insert(self, __x):
          return _eclipse.intSet_insert(self, __x)
      __swig_destroy__ = _eclipse.delete_intSet
      __del__ = lambda self: None
  intSet_swigregister = _eclipse.intSet_swigregister
  intSet_swigregister(intSet)
  
  class ConstCharVector(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, ConstCharVector, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, ConstCharVector, name)
      __repr__ = _swig_repr
  
      def iterator(self):
          return _eclipse.ConstCharVector_iterator(self)
      def __iter__(self):
          return self.iterator()
  
      def __nonzero__(self):
          return _eclipse.ConstCharVector___nonzero__(self)
  
      def __bool__(self):
          return _eclipse.ConstCharVector___bool__(self)
  
      def __len__(self):
          return _eclipse.ConstCharVector___len__(self)
  
      def __getslice__(self, i, j):
          return _eclipse.ConstCharVector___getslice__(self, i, j)
  
      def __setslice__(self, *args):
          return _eclipse.ConstCharVector___setslice__(self, *args)
  
      def __delslice__(self, i, j):
          return _eclipse.ConstCharVector___delslice__(self, i, j)
  
      def __delitem__(self, *args):
          return _eclipse.ConstCharVector___delitem__(self, *args)
  
      def __getitem__(self, *args):
          return _eclipse.ConstCharVector___getitem__(self, *args)
  
      def __setitem__(self, *args):
          return _eclipse.ConstCharVector___setitem__(self, *args)
  
      def pop(self):
          return _eclipse.ConstCharVector_pop(self)
  
      def append(self, x):
          return _eclipse.ConstCharVector_append(self, x)
  
      def empty(self):
          return _eclipse.ConstCharVector_empty(self)
  
      def size(self):
          return _eclipse.ConstCharVector_size(self)
  
      def swap(self, v):
          return _eclipse.ConstCharVector_swap(self, v)
  
      def begin(self):
          return _eclipse.ConstCharVector_begin(self)
  
      def end(self):
          return _eclipse.ConstCharVector_end(self)
  
      def rbegin(self):
          return _eclipse.ConstCharVector_rbegin(self)
  
      def rend(self):
          return _eclipse.ConstCharVector_rend(self)
  
      def clear(self):
          return _eclipse.ConstCharVector_clear(self)
  
      def get_allocator(self):
          return _eclipse.ConstCharVector_get_allocator(self)
  
      def pop_back(self):
          return _eclipse.ConstCharVector_pop_back(self)
  
      def erase(self, *args):
          return _eclipse.ConstCharVector_erase(self, *args)
  
      def __init__(self, *args):
          this = _eclipse.new_ConstCharVector(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
  
      def push_back(self, x):
          return _eclipse.ConstCharVector_push_back(self, x)
  
      def front(self):
          return _eclipse.ConstCharVector_front(self)
  
      def back(self):
          return _eclipse.ConstCharVector_back(self)
  
      def assign(self, n, x):
          return _eclipse.ConstCharVector_assign(self, n, x)
  
      def resize(self, *args):
          return _eclipse.ConstCharVector_resize(self, *args)
  
      def insert(self, *args):
          return _eclipse.ConstCharVector_insert(self, *args)
  
      def reserve(self, n):
          return _eclipse.ConstCharVector_reserve(self, n)
  
      def capacity(self):
          return _eclipse.ConstCharVector_capacity(self)
      __swig_destroy__ = _eclipse.delete_ConstCharVector
      __del__ = lambda self: None
  ConstCharVector_swigregister = _eclipse.ConstCharVector_swigregister
  ConstCharVector_swigregister(ConstCharVector)
  
  class MultiArray(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, MultiArray, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, MultiArray, name)
      __repr__ = _swig_repr
  
      def iterator(self):
          return _eclipse.MultiArray_iterator(self)
      def __iter__(self):
          return self.iterator()
  
      def __nonzero__(self):
          return _eclipse.MultiArray___nonzero__(self)
  
      def __bool__(self):
          return _eclipse.MultiArray___bool__(self)
  
      def __len__(self):
          return _eclipse.MultiArray___len__(self)
  
      def __getslice__(self, i, j):
          return _eclipse.MultiArray___getslice__(self, i, j)
  
      def __setslice__(self, *args):
          return _eclipse.MultiArray___setslice__(self, *args)
  
      def __delslice__(self, i, j):
          return _eclipse.MultiArray___delslice__(self, i, j)
  
      def __delitem__(self, *args):
          return _eclipse.MultiArray___delitem__(self, *args)
  
      def __getitem__(self, *args):
          return _eclipse.MultiArray___getitem__(self, *args)
  
      def __setitem__(self, *args):
          return _eclipse.MultiArray___setitem__(self, *args)
  
      def pop(self):
          return _eclipse.MultiArray_pop(self)
  
      def append(self, x):
          return _eclipse.MultiArray_append(self, x)
  
      def empty(self):
          return _eclipse.MultiArray_empty(self)
  
      def size(self):
          return _eclipse.MultiArray_size(self)
  
      def swap(self, v):
          return _eclipse.MultiArray_swap(self, v)
  
      def begin(self):
          return _eclipse.MultiArray_begin(self)
  
      def end(self):
          return _eclipse.MultiArray_end(self)
  
      def rbegin(self):
          return _eclipse.MultiArray_rbegin(self)
  
      def rend(self):
          return _eclipse.MultiArray_rend(self)
  
      def clear(self):
          return _eclipse.MultiArray_clear(self)
  
      def get_allocator(self):
          return _eclipse.MultiArray_get_allocator(self)
  
      def pop_back(self):
          return _eclipse.MultiArray_pop_back(self)
  
      def erase(self, *args):
          return _eclipse.MultiArray_erase(self, *args)
  
      def __init__(self, *args):
          this = _eclipse.new_MultiArray(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
  
      def push_back(self, x):
          return _eclipse.MultiArray_push_back(self, x)
  
      def front(self):
          return _eclipse.MultiArray_front(self)
  
      def back(self):
          return _eclipse.MultiArray_back(self)
  
      def assign(self, n, x):
          return _eclipse.MultiArray_assign(self, n, x)
  
      def resize(self, *args):
          return _eclipse.MultiArray_resize(self, *args)
  
      def insert(self, *args):
          return _eclipse.MultiArray_insert(self, *args)
  
      def reserve(self, n):
          return _eclipse.MultiArray_reserve(self, n)
  
      def capacity(self):
          return _eclipse.MultiArray_capacity(self)
      __swig_destroy__ = _eclipse.delete_MultiArray
      __del__ = lambda self: None
  MultiArray_swigregister = _eclipse.MultiArray_swigregister
  MultiArray_swigregister(MultiArray)
  
  class SysModel(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, SysModel, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, SysModel, name)
      __repr__ = _swig_repr
  
      def __init__(self, *args):
          this = _eclipse.new_SysModel(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
      __swig_destroy__ = _eclipse.delete_SysModel
      __del__ = lambda self: None
  
      def SelfInit(self):
          return _eclipse.SysModel_SelfInit(self)
  
      def CrossInit(self):
          return _eclipse.SysModel_CrossInit(self)
  
      def IntegratedInit(self):
          return _eclipse.SysModel_IntegratedInit(self)
  
      def UpdateState(self, CurrentSimNanos):
          return _eclipse.SysModel_UpdateState(self, CurrentSimNanos)
  
      def Reset(self, CurrentSimNanos):
          return _eclipse.SysModel_Reset(self, CurrentSimNanos)
      __swig_setmethods__["ModelTag"] = _eclipse.SysModel_ModelTag_set
      __swig_getmethods__["ModelTag"] = _eclipse.SysModel_ModelTag_get
      if _newclass:
          ModelTag = _swig_property(_eclipse.SysModel_ModelTag_get, _eclipse.SysModel_ModelTag_set)
      __swig_setmethods__["CallCounts"] = _eclipse.SysModel_CallCounts_set
      __swig_getmethods__["CallCounts"] = _eclipse.SysModel_CallCounts_get
      if _newclass:
          CallCounts = _swig_property(_eclipse.SysModel_CallCounts_get, _eclipse.SysModel_CallCounts_set)
      __swig_setmethods__["RNGSeed"] = _eclipse.SysModel_RNGSeed_set
      __swig_getmethods__["RNGSeed"] = _eclipse.SysModel_RNGSeed_get
      if _newclass:
          RNGSeed = _swig_property(_eclipse.SysModel_RNGSeed_get, _eclipse.SysModel_RNGSeed_set)
      __swig_setmethods__["moduleID"] = _eclipse.SysModel_moduleID_set
      __swig_getmethods__["moduleID"] = _eclipse.SysModel_moduleID_get
      if _newclass:
          moduleID = _swig_property(_eclipse.SysModel_moduleID_get, _eclipse.SysModel_moduleID_set)
  SysModel_swigregister = _eclipse.SysModel_swigregister
  SysModel_swigregister(SysModel)
  
  class Eclipse(SysModel):
      __swig_setmethods__ = {}
      for _s in [SysModel]:
          __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
      __setattr__ = lambda self, name, value: _swig_setattr(self, Eclipse, name, value)
      __swig_getmethods__ = {}
      for _s in [SysModel]:
          __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
      __getattr__ = lambda self, name: _swig_getattr(self, Eclipse, name)
      __repr__ = _swig_repr
      __swig_destroy__ = _eclipse.delete_Eclipse
      __del__ = lambda self: None
  
      def SelfInit(self):
          return _eclipse.Eclipse_SelfInit(self)
  
      def CrossInit(self):
          return _eclipse.Eclipse_CrossInit(self)
  
      def UpdateState(self, CurrentSimNanos):
          return _eclipse.Eclipse_UpdateState(self, CurrentSimNanos)
  
      def writeOutputMessages(self, CurrentClock):
          return _eclipse.Eclipse_writeOutputMessages(self, CurrentClock)
  
      def addPositionMsgName(self, msgName):
          return _eclipse.Eclipse_addPositionMsgName(self, msgName)
  
      def addPlanetName(self, planetName):
          return _eclipse.Eclipse_addPlanetName(self, planetName)
      __swig_setmethods__["outputBufferCount"] = _eclipse.Eclipse_outputBufferCount_set
      __swig_getmethods__["outputBufferCount"] = _eclipse.Eclipse_outputBufferCount_get
      if _newclass:
          outputBufferCount = _swig_property(_eclipse.Eclipse_outputBufferCount_get, _eclipse.Eclipse_outputBufferCount_set)
      __swig_setmethods__["sunInMsgName"] = _eclipse.Eclipse_sunInMsgName_set
      __swig_getmethods__["sunInMsgName"] = _eclipse.Eclipse_sunInMsgName_get
      if _newclass:
          sunInMsgName = _swig_property(_eclipse.Eclipse_sunInMsgName_get, _eclipse.Eclipse_sunInMsgName_set)
  
      def __init__(self, *args):
          this = _eclipse.new_Eclipse(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
  Eclipse_swigregister = _eclipse.Eclipse_swigregister
  Eclipse_swigregister(Eclipse)
  
  class EclipseSimMsg(_object):
      __swig_setmethods__ = {}
      __setattr__ = lambda self, name, value: _swig_setattr(self, EclipseSimMsg, name, value)
      __swig_getmethods__ = {}
      __getattr__ = lambda self, name: _swig_getattr(self, EclipseSimMsg, name)
      __repr__ = _swig_repr
      __swig_setmethods__["shadowFactor"] = _eclipse.EclipseSimMsg_shadowFactor_set
      __swig_getmethods__["shadowFactor"] = _eclipse.EclipseSimMsg_shadowFactor_get
      if _newclass:
          shadowFactor = _swig_property(_eclipse.EclipseSimMsg_shadowFactor_get, _eclipse.EclipseSimMsg_shadowFactor_set)
  
      def __init__(self, *args):
          this = _eclipse.new_EclipseSimMsg(*args)
          try:
              self.this.append(this)
          except __builtin__.Exception:
              self.this = this
      __swig_destroy__ = _eclipse.delete_EclipseSimMsg
      __del__ = lambda self: None
  EclipseSimMsg_swigregister = _eclipse.EclipseSimMsg_swigregister
  EclipseSimMsg_swigregister(EclipseSimMsg)
  
  sizeof_EclipseSimMsg = _eclipse.sizeof_EclipseSimMsg
  
  import sys
  protectAllClasses(sys.modules[__name__])
  
  # This file is compatible with both classic and new-style classes.
  
  
  