1271 lines
77 KiB
Python
1271 lines
77 KiB
Python
# This file was automatically generated by SWIG (http://www.swig.org).
|
|
# Version 1.3.40
|
|
#
|
|
# 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.
|
|
|
|
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('_hedvigpyc', [dirname(__file__)])
|
|
except ImportError:
|
|
import _hedvigpyc
|
|
return _hedvigpyc
|
|
if fp is not None:
|
|
try:
|
|
_mod = imp.load_module('_hedvigpyc', fp, pathname, description)
|
|
finally:
|
|
fp.close()
|
|
return _mod
|
|
_hedvigpyc = swig_import_helper()
|
|
del swig_import_helper
|
|
else:
|
|
import _hedvigpyc
|
|
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 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__ = _hedvigpyc.delete_SwigPyIterator
|
|
__del__ = lambda self : None;
|
|
def value(self): return _hedvigpyc.SwigPyIterator_value(self)
|
|
def incr(self, n = 1): return _hedvigpyc.SwigPyIterator_incr(self, n)
|
|
def decr(self, n = 1): return _hedvigpyc.SwigPyIterator_decr(self, n)
|
|
def distance(self, *args): return _hedvigpyc.SwigPyIterator_distance(self, *args)
|
|
def equal(self, *args): return _hedvigpyc.SwigPyIterator_equal(self, *args)
|
|
def copy(self): return _hedvigpyc.SwigPyIterator_copy(self)
|
|
def next(self): return _hedvigpyc.SwigPyIterator_next(self)
|
|
def __next__(self): return _hedvigpyc.SwigPyIterator___next__(self)
|
|
def previous(self): return _hedvigpyc.SwigPyIterator_previous(self)
|
|
def advance(self, *args): return _hedvigpyc.SwigPyIterator_advance(self, *args)
|
|
def __eq__(self, *args): return _hedvigpyc.SwigPyIterator___eq__(self, *args)
|
|
def __ne__(self, *args): return _hedvigpyc.SwigPyIterator___ne__(self, *args)
|
|
def __iadd__(self, *args): return _hedvigpyc.SwigPyIterator___iadd__(self, *args)
|
|
def __isub__(self, *args): return _hedvigpyc.SwigPyIterator___isub__(self, *args)
|
|
def __add__(self, *args): return _hedvigpyc.SwigPyIterator___add__(self, *args)
|
|
def __sub__(self, *args): return _hedvigpyc.SwigPyIterator___sub__(self, *args)
|
|
def __iter__(self): return self
|
|
SwigPyIterator_swigregister = _hedvigpyc.SwigPyIterator_swigregister
|
|
SwigPyIterator_swigregister(SwigPyIterator)
|
|
|
|
|
|
def cdata(*args):
|
|
return _hedvigpyc.cdata(*args)
|
|
cdata = _hedvigpyc.cdata
|
|
|
|
def memmove(*args):
|
|
return _hedvigpyc.memmove(*args)
|
|
memmove = _hedvigpyc.memmove
|
|
class map_string_string(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, map_string_string, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, map_string_string, name)
|
|
__repr__ = _swig_repr
|
|
def iterator(self): return _hedvigpyc.map_string_string_iterator(self)
|
|
def __iter__(self): return self.iterator()
|
|
def __nonzero__(self): return _hedvigpyc.map_string_string___nonzero__(self)
|
|
def __bool__(self): return _hedvigpyc.map_string_string___bool__(self)
|
|
def __len__(self): return _hedvigpyc.map_string_string___len__(self)
|
|
def __getitem__(self, *args): return _hedvigpyc.map_string_string___getitem__(self, *args)
|
|
def __delitem__(self, *args): return _hedvigpyc.map_string_string___delitem__(self, *args)
|
|
def has_key(self, *args): return _hedvigpyc.map_string_string_has_key(self, *args)
|
|
def keys(self): return _hedvigpyc.map_string_string_keys(self)
|
|
def values(self): return _hedvigpyc.map_string_string_values(self)
|
|
def items(self): return _hedvigpyc.map_string_string_items(self)
|
|
def __contains__(self, *args): return _hedvigpyc.map_string_string___contains__(self, *args)
|
|
def key_iterator(self): return _hedvigpyc.map_string_string_key_iterator(self)
|
|
def value_iterator(self): return _hedvigpyc.map_string_string_value_iterator(self)
|
|
def __iter__(self): return self.key_iterator()
|
|
def iterkeys(self): return self.key_iterator()
|
|
def itervalues(self): return self.value_iterator()
|
|
def iteritems(self): return self.iterator()
|
|
def __setitem__(self, *args): return _hedvigpyc.map_string_string___setitem__(self, *args)
|
|
def __init__(self, *args):
|
|
this = _hedvigpyc.new_map_string_string(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def empty(self): return _hedvigpyc.map_string_string_empty(self)
|
|
def size(self): return _hedvigpyc.map_string_string_size(self)
|
|
def clear(self): return _hedvigpyc.map_string_string_clear(self)
|
|
def swap(self, *args): return _hedvigpyc.map_string_string_swap(self, *args)
|
|
def get_allocator(self): return _hedvigpyc.map_string_string_get_allocator(self)
|
|
def begin(self): return _hedvigpyc.map_string_string_begin(self)
|
|
def end(self): return _hedvigpyc.map_string_string_end(self)
|
|
def rbegin(self): return _hedvigpyc.map_string_string_rbegin(self)
|
|
def rend(self): return _hedvigpyc.map_string_string_rend(self)
|
|
def count(self, *args): return _hedvigpyc.map_string_string_count(self, *args)
|
|
def erase(self, *args): return _hedvigpyc.map_string_string_erase(self, *args)
|
|
def find(self, *args): return _hedvigpyc.map_string_string_find(self, *args)
|
|
def lower_bound(self, *args): return _hedvigpyc.map_string_string_lower_bound(self, *args)
|
|
def upper_bound(self, *args): return _hedvigpyc.map_string_string_upper_bound(self, *args)
|
|
__swig_destroy__ = _hedvigpyc.delete_map_string_string
|
|
__del__ = lambda self : None;
|
|
map_string_string_swigregister = _hedvigpyc.map_string_string_swigregister
|
|
map_string_string_swigregister(map_string_string)
|
|
|
|
class map_int_string(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, map_int_string, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, map_int_string, name)
|
|
__repr__ = _swig_repr
|
|
def iterator(self): return _hedvigpyc.map_int_string_iterator(self)
|
|
def __iter__(self): return self.iterator()
|
|
def __nonzero__(self): return _hedvigpyc.map_int_string___nonzero__(self)
|
|
def __bool__(self): return _hedvigpyc.map_int_string___bool__(self)
|
|
def __len__(self): return _hedvigpyc.map_int_string___len__(self)
|
|
def __getitem__(self, *args): return _hedvigpyc.map_int_string___getitem__(self, *args)
|
|
def __delitem__(self, *args): return _hedvigpyc.map_int_string___delitem__(self, *args)
|
|
def has_key(self, *args): return _hedvigpyc.map_int_string_has_key(self, *args)
|
|
def keys(self): return _hedvigpyc.map_int_string_keys(self)
|
|
def values(self): return _hedvigpyc.map_int_string_values(self)
|
|
def items(self): return _hedvigpyc.map_int_string_items(self)
|
|
def __contains__(self, *args): return _hedvigpyc.map_int_string___contains__(self, *args)
|
|
def key_iterator(self): return _hedvigpyc.map_int_string_key_iterator(self)
|
|
def value_iterator(self): return _hedvigpyc.map_int_string_value_iterator(self)
|
|
def __iter__(self): return self.key_iterator()
|
|
def iterkeys(self): return self.key_iterator()
|
|
def itervalues(self): return self.value_iterator()
|
|
def iteritems(self): return self.iterator()
|
|
def __setitem__(self, *args): return _hedvigpyc.map_int_string___setitem__(self, *args)
|
|
def __init__(self, *args):
|
|
this = _hedvigpyc.new_map_int_string(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def empty(self): return _hedvigpyc.map_int_string_empty(self)
|
|
def size(self): return _hedvigpyc.map_int_string_size(self)
|
|
def clear(self): return _hedvigpyc.map_int_string_clear(self)
|
|
def swap(self, *args): return _hedvigpyc.map_int_string_swap(self, *args)
|
|
def get_allocator(self): return _hedvigpyc.map_int_string_get_allocator(self)
|
|
def begin(self): return _hedvigpyc.map_int_string_begin(self)
|
|
def end(self): return _hedvigpyc.map_int_string_end(self)
|
|
def rbegin(self): return _hedvigpyc.map_int_string_rbegin(self)
|
|
def rend(self): return _hedvigpyc.map_int_string_rend(self)
|
|
def count(self, *args): return _hedvigpyc.map_int_string_count(self, *args)
|
|
def erase(self, *args): return _hedvigpyc.map_int_string_erase(self, *args)
|
|
def find(self, *args): return _hedvigpyc.map_int_string_find(self, *args)
|
|
def lower_bound(self, *args): return _hedvigpyc.map_int_string_lower_bound(self, *args)
|
|
def upper_bound(self, *args): return _hedvigpyc.map_int_string_upper_bound(self, *args)
|
|
__swig_destroy__ = _hedvigpyc.delete_map_int_string
|
|
__del__ = lambda self : None;
|
|
map_int_string_swigregister = _hedvigpyc.map_int_string_swigregister
|
|
map_int_string_swigregister(map_int_string)
|
|
|
|
class blkId_vector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, blkId_vector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, blkId_vector, name)
|
|
__repr__ = _swig_repr
|
|
def iterator(self): return _hedvigpyc.blkId_vector_iterator(self)
|
|
def __iter__(self): return self.iterator()
|
|
def __nonzero__(self): return _hedvigpyc.blkId_vector___nonzero__(self)
|
|
def __bool__(self): return _hedvigpyc.blkId_vector___bool__(self)
|
|
def __len__(self): return _hedvigpyc.blkId_vector___len__(self)
|
|
def pop(self): return _hedvigpyc.blkId_vector_pop(self)
|
|
def __getslice__(self, *args): return _hedvigpyc.blkId_vector___getslice__(self, *args)
|
|
def __setslice__(self, *args): return _hedvigpyc.blkId_vector___setslice__(self, *args)
|
|
def __delslice__(self, *args): return _hedvigpyc.blkId_vector___delslice__(self, *args)
|
|
def __delitem__(self, *args): return _hedvigpyc.blkId_vector___delitem__(self, *args)
|
|
def __getitem__(self, *args): return _hedvigpyc.blkId_vector___getitem__(self, *args)
|
|
def __setitem__(self, *args): return _hedvigpyc.blkId_vector___setitem__(self, *args)
|
|
def append(self, *args): return _hedvigpyc.blkId_vector_append(self, *args)
|
|
def empty(self): return _hedvigpyc.blkId_vector_empty(self)
|
|
def size(self): return _hedvigpyc.blkId_vector_size(self)
|
|
def clear(self): return _hedvigpyc.blkId_vector_clear(self)
|
|
def swap(self, *args): return _hedvigpyc.blkId_vector_swap(self, *args)
|
|
def get_allocator(self): return _hedvigpyc.blkId_vector_get_allocator(self)
|
|
def begin(self): return _hedvigpyc.blkId_vector_begin(self)
|
|
def end(self): return _hedvigpyc.blkId_vector_end(self)
|
|
def rbegin(self): return _hedvigpyc.blkId_vector_rbegin(self)
|
|
def rend(self): return _hedvigpyc.blkId_vector_rend(self)
|
|
def pop_back(self): return _hedvigpyc.blkId_vector_pop_back(self)
|
|
def erase(self, *args): return _hedvigpyc.blkId_vector_erase(self, *args)
|
|
def __init__(self, *args):
|
|
this = _hedvigpyc.new_blkId_vector(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _hedvigpyc.blkId_vector_push_back(self, *args)
|
|
def front(self): return _hedvigpyc.blkId_vector_front(self)
|
|
def back(self): return _hedvigpyc.blkId_vector_back(self)
|
|
def assign(self, *args): return _hedvigpyc.blkId_vector_assign(self, *args)
|
|
def resize(self, *args): return _hedvigpyc.blkId_vector_resize(self, *args)
|
|
def insert(self, *args): return _hedvigpyc.blkId_vector_insert(self, *args)
|
|
def reserve(self, *args): return _hedvigpyc.blkId_vector_reserve(self, *args)
|
|
def capacity(self): return _hedvigpyc.blkId_vector_capacity(self)
|
|
__swig_destroy__ = _hedvigpyc.delete_blkId_vector
|
|
__del__ = lambda self : None;
|
|
blkId_vector_swigregister = _hedvigpyc.blkId_vector_swigregister
|
|
blkId_vector_swigregister(blkId_vector)
|
|
|
|
class buffer_vector(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, buffer_vector, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, buffer_vector, name)
|
|
__repr__ = _swig_repr
|
|
def iterator(self): return _hedvigpyc.buffer_vector_iterator(self)
|
|
def __iter__(self): return self.iterator()
|
|
def __nonzero__(self): return _hedvigpyc.buffer_vector___nonzero__(self)
|
|
def __bool__(self): return _hedvigpyc.buffer_vector___bool__(self)
|
|
def __len__(self): return _hedvigpyc.buffer_vector___len__(self)
|
|
def pop(self): return _hedvigpyc.buffer_vector_pop(self)
|
|
def __getslice__(self, *args): return _hedvigpyc.buffer_vector___getslice__(self, *args)
|
|
def __setslice__(self, *args): return _hedvigpyc.buffer_vector___setslice__(self, *args)
|
|
def __delslice__(self, *args): return _hedvigpyc.buffer_vector___delslice__(self, *args)
|
|
def __delitem__(self, *args): return _hedvigpyc.buffer_vector___delitem__(self, *args)
|
|
def __getitem__(self, *args): return _hedvigpyc.buffer_vector___getitem__(self, *args)
|
|
def __setitem__(self, *args): return _hedvigpyc.buffer_vector___setitem__(self, *args)
|
|
def append(self, *args): return _hedvigpyc.buffer_vector_append(self, *args)
|
|
def empty(self): return _hedvigpyc.buffer_vector_empty(self)
|
|
def size(self): return _hedvigpyc.buffer_vector_size(self)
|
|
def clear(self): return _hedvigpyc.buffer_vector_clear(self)
|
|
def swap(self, *args): return _hedvigpyc.buffer_vector_swap(self, *args)
|
|
def get_allocator(self): return _hedvigpyc.buffer_vector_get_allocator(self)
|
|
def begin(self): return _hedvigpyc.buffer_vector_begin(self)
|
|
def end(self): return _hedvigpyc.buffer_vector_end(self)
|
|
def rbegin(self): return _hedvigpyc.buffer_vector_rbegin(self)
|
|
def rend(self): return _hedvigpyc.buffer_vector_rend(self)
|
|
def pop_back(self): return _hedvigpyc.buffer_vector_pop_back(self)
|
|
def erase(self, *args): return _hedvigpyc.buffer_vector_erase(self, *args)
|
|
def __init__(self, *args):
|
|
this = _hedvigpyc.new_buffer_vector(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def push_back(self, *args): return _hedvigpyc.buffer_vector_push_back(self, *args)
|
|
def front(self): return _hedvigpyc.buffer_vector_front(self)
|
|
def back(self): return _hedvigpyc.buffer_vector_back(self)
|
|
def assign(self, *args): return _hedvigpyc.buffer_vector_assign(self, *args)
|
|
def resize(self, *args): return _hedvigpyc.buffer_vector_resize(self, *args)
|
|
def insert(self, *args): return _hedvigpyc.buffer_vector_insert(self, *args)
|
|
def reserve(self, *args): return _hedvigpyc.buffer_vector_reserve(self, *args)
|
|
def capacity(self): return _hedvigpyc.buffer_vector_capacity(self)
|
|
__swig_destroy__ = _hedvigpyc.delete_buffer_vector
|
|
__del__ = lambda self : None;
|
|
buffer_vector_swigregister = _hedvigpyc.buffer_vector_swigregister
|
|
buffer_vector_swigregister(buffer_vector)
|
|
|
|
class set_string(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, set_string, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, set_string, name)
|
|
__repr__ = _swig_repr
|
|
def iterator(self): return _hedvigpyc.set_string_iterator(self)
|
|
def __iter__(self): return self.iterator()
|
|
def __nonzero__(self): return _hedvigpyc.set_string___nonzero__(self)
|
|
def __bool__(self): return _hedvigpyc.set_string___bool__(self)
|
|
def __len__(self): return _hedvigpyc.set_string___len__(self)
|
|
def append(self, *args): return _hedvigpyc.set_string_append(self, *args)
|
|
def __contains__(self, *args): return _hedvigpyc.set_string___contains__(self, *args)
|
|
def __getitem__(self, *args): return _hedvigpyc.set_string___getitem__(self, *args)
|
|
def __init__(self, *args):
|
|
this = _hedvigpyc.new_set_string(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def empty(self): return _hedvigpyc.set_string_empty(self)
|
|
def size(self): return _hedvigpyc.set_string_size(self)
|
|
def clear(self): return _hedvigpyc.set_string_clear(self)
|
|
def swap(self, *args): return _hedvigpyc.set_string_swap(self, *args)
|
|
def count(self, *args): return _hedvigpyc.set_string_count(self, *args)
|
|
def begin(self): return _hedvigpyc.set_string_begin(self)
|
|
def end(self): return _hedvigpyc.set_string_end(self)
|
|
def rbegin(self): return _hedvigpyc.set_string_rbegin(self)
|
|
def rend(self): return _hedvigpyc.set_string_rend(self)
|
|
def erase(self, *args): return _hedvigpyc.set_string_erase(self, *args)
|
|
def find(self, *args): return _hedvigpyc.set_string_find(self, *args)
|
|
def lower_bound(self, *args): return _hedvigpyc.set_string_lower_bound(self, *args)
|
|
def upper_bound(self, *args): return _hedvigpyc.set_string_upper_bound(self, *args)
|
|
def equal_range(self, *args): return _hedvigpyc.set_string_equal_range(self, *args)
|
|
def insert(self, *args): return _hedvigpyc.set_string_insert(self, *args)
|
|
__swig_destroy__ = _hedvigpyc.delete_set_string
|
|
__del__ = lambda self : None;
|
|
set_string_swigregister = _hedvigpyc.set_string_swigregister
|
|
set_string_swigregister(set_string)
|
|
|
|
class map_tgt_string(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, map_tgt_string, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, map_tgt_string, name)
|
|
__repr__ = _swig_repr
|
|
def iterator(self): return _hedvigpyc.map_tgt_string_iterator(self)
|
|
def __iter__(self): return self.iterator()
|
|
def __nonzero__(self): return _hedvigpyc.map_tgt_string___nonzero__(self)
|
|
def __bool__(self): return _hedvigpyc.map_tgt_string___bool__(self)
|
|
def __len__(self): return _hedvigpyc.map_tgt_string___len__(self)
|
|
def __getitem__(self, *args): return _hedvigpyc.map_tgt_string___getitem__(self, *args)
|
|
def __delitem__(self, *args): return _hedvigpyc.map_tgt_string___delitem__(self, *args)
|
|
def has_key(self, *args): return _hedvigpyc.map_tgt_string_has_key(self, *args)
|
|
def keys(self): return _hedvigpyc.map_tgt_string_keys(self)
|
|
def values(self): return _hedvigpyc.map_tgt_string_values(self)
|
|
def items(self): return _hedvigpyc.map_tgt_string_items(self)
|
|
def __contains__(self, *args): return _hedvigpyc.map_tgt_string___contains__(self, *args)
|
|
def key_iterator(self): return _hedvigpyc.map_tgt_string_key_iterator(self)
|
|
def value_iterator(self): return _hedvigpyc.map_tgt_string_value_iterator(self)
|
|
def __iter__(self): return self.key_iterator()
|
|
def iterkeys(self): return self.key_iterator()
|
|
def itervalues(self): return self.value_iterator()
|
|
def iteritems(self): return self.iterator()
|
|
def __setitem__(self, *args): return _hedvigpyc.map_tgt_string___setitem__(self, *args)
|
|
def __init__(self, *args):
|
|
this = _hedvigpyc.new_map_tgt_string(*args)
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
def empty(self): return _hedvigpyc.map_tgt_string_empty(self)
|
|
def size(self): return _hedvigpyc.map_tgt_string_size(self)
|
|
def clear(self): return _hedvigpyc.map_tgt_string_clear(self)
|
|
def swap(self, *args): return _hedvigpyc.map_tgt_string_swap(self, *args)
|
|
def get_allocator(self): return _hedvigpyc.map_tgt_string_get_allocator(self)
|
|
def begin(self): return _hedvigpyc.map_tgt_string_begin(self)
|
|
def end(self): return _hedvigpyc.map_tgt_string_end(self)
|
|
def rbegin(self): return _hedvigpyc.map_tgt_string_rbegin(self)
|
|
def rend(self): return _hedvigpyc.map_tgt_string_rend(self)
|
|
def count(self, *args): return _hedvigpyc.map_tgt_string_count(self, *args)
|
|
def erase(self, *args): return _hedvigpyc.map_tgt_string_erase(self, *args)
|
|
def find(self, *args): return _hedvigpyc.map_tgt_string_find(self, *args)
|
|
def lower_bound(self, *args): return _hedvigpyc.map_tgt_string_lower_bound(self, *args)
|
|
def upper_bound(self, *args): return _hedvigpyc.map_tgt_string_upper_bound(self, *args)
|
|
__swig_destroy__ = _hedvigpyc.delete_map_tgt_string
|
|
__del__ = lambda self : None;
|
|
map_tgt_string_swigregister = _hedvigpyc.map_tgt_string_swigregister
|
|
map_tgt_string_swigregister(map_tgt_string)
|
|
|
|
class Callback(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Callback, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Callback, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
if self.__class__ == Callback:
|
|
_self = None
|
|
else:
|
|
_self = self
|
|
this = _hedvigpyc.new_Callback(_self, )
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_Callback
|
|
__del__ = lambda self : None;
|
|
def call(self, *args): return _hedvigpyc.Callback_call(self, *args)
|
|
def __disown__(self):
|
|
self.this.disown()
|
|
_hedvigpyc.disown_Callback(self)
|
|
return weakref_proxy(self)
|
|
Callback_swigregister = _hedvigpyc.Callback_swigregister
|
|
Callback_swigregister(Callback)
|
|
|
|
class ObjWithPyCallback(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ObjWithPyCallback, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ObjWithPyCallback, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_ObjWithPyCallback()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_ObjWithPyCallback
|
|
__del__ = lambda self : None;
|
|
def setCallback(self, *args):
|
|
if len(args) == 1 and (not isinstance(args[0], Callback) and callable(args[0])):
|
|
class CallableWrapper(Callback):
|
|
def __init__(self, f):
|
|
super(CallableWrapper, self).__init__()
|
|
self.f_ = f
|
|
def call(self, obj):
|
|
self.f_(obj)
|
|
|
|
args = tuple([CallableWrapper(args[0])])
|
|
args[0].__disown__()
|
|
elif len(args) == 1 and isinstance(args[0], Callback):
|
|
args[0].__disown__()
|
|
|
|
|
|
return _hedvigpyc.ObjWithPyCallback_setCallback(self, *args)
|
|
|
|
def call(self): return _hedvigpyc.ObjWithPyCallback_call(self)
|
|
def getTgtInstance(self, *args): return _hedvigpyc.ObjWithPyCallback_getTgtInstance(self, *args)
|
|
def describeVirtualDisk(self, *args): return _hedvigpyc.ObjWithPyCallback_describeVirtualDisk(self, *args)
|
|
def getLunCinder(self, *args): return _hedvigpyc.ObjWithPyCallback_getLunCinder(self, *args)
|
|
def addLun(self, *args): return _hedvigpyc.ObjWithPyCallback_addLun(self, *args)
|
|
def deleteLun(self, *args): return _hedvigpyc.ObjWithPyCallback_deleteLun(self, *args)
|
|
def addAccess(self, *args): return _hedvigpyc.ObjWithPyCallback_addAccess(self, *args)
|
|
def snapshotFromTgt(self, *args): return _hedvigpyc.ObjWithPyCallback_snapshotFromTgt(self, *args)
|
|
def snapshot(self, *args): return _hedvigpyc.ObjWithPyCallback_snapshot(self, *args)
|
|
def deleteSnapshot(self, *args): return _hedvigpyc.ObjWithPyCallback_deleteSnapshot(self, *args)
|
|
def createVirtualDisk(self, *args): return _hedvigpyc.ObjWithPyCallback_createVirtualDisk(self, *args)
|
|
def resizeVirtualDisk(self, *args): return _hedvigpyc.ObjWithPyCallback_resizeVirtualDisk(self, *args)
|
|
def deleteVirtualDisk(self, *args): return _hedvigpyc.ObjWithPyCallback_deleteVirtualDisk(self, *args)
|
|
def getIqn(self, *args): return _hedvigpyc.ObjWithPyCallback_getIqn(self, *args)
|
|
__swig_setmethods__["errorCode_"] = _hedvigpyc.ObjWithPyCallback_errorCode__set
|
|
__swig_getmethods__["errorCode_"] = _hedvigpyc.ObjWithPyCallback_errorCode__get
|
|
if _newclass:errorCode_ = _swig_property(_hedvigpyc.ObjWithPyCallback_errorCode__get, _hedvigpyc.ObjWithPyCallback_errorCode__set)
|
|
__swig_setmethods__["error_"] = _hedvigpyc.ObjWithPyCallback_error__set
|
|
__swig_getmethods__["error_"] = _hedvigpyc.ObjWithPyCallback_error__get
|
|
if _newclass:error_ = _swig_property(_hedvigpyc.ObjWithPyCallback_error__get, _hedvigpyc.ObjWithPyCallback_error__set)
|
|
__swig_setmethods__["wfd_"] = _hedvigpyc.ObjWithPyCallback_wfd__set
|
|
__swig_getmethods__["wfd_"] = _hedvigpyc.ObjWithPyCallback_wfd__get
|
|
if _newclass:wfd_ = _swig_property(_hedvigpyc.ObjWithPyCallback_wfd__get, _hedvigpyc.ObjWithPyCallback_wfd__set)
|
|
ObjWithPyCallback_swigregister = _hedvigpyc.ObjWithPyCallback_swigregister
|
|
ObjWithPyCallback_swigregister(ObjWithPyCallback)
|
|
|
|
class HGetTgtInstanceOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HGetTgtInstanceOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HGetTgtInstanceOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["host_"] = _hedvigpyc.HGetTgtInstanceOp_host__set
|
|
__swig_getmethods__["host_"] = _hedvigpyc.HGetTgtInstanceOp_host__get
|
|
if _newclass:host_ = _swig_property(_hedvigpyc.HGetTgtInstanceOp_host__get, _hedvigpyc.HGetTgtInstanceOp_host__set)
|
|
__swig_setmethods__["tgtMap_"] = _hedvigpyc.HGetTgtInstanceOp_tgtMap__set
|
|
__swig_getmethods__["tgtMap_"] = _hedvigpyc.HGetTgtInstanceOp_tgtMap__get
|
|
if _newclass:tgtMap_ = _swig_property(_hedvigpyc.HGetTgtInstanceOp_tgtMap__get, _hedvigpyc.HGetTgtInstanceOp_tgtMap__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HGetTgtInstanceOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HGetTgtInstanceOp
|
|
__del__ = lambda self : None;
|
|
HGetTgtInstanceOp_swigregister = _hedvigpyc.HGetTgtInstanceOp_swigregister
|
|
HGetTgtInstanceOp_swigregister(HGetTgtInstanceOp)
|
|
|
|
class HDescribeVirtualDiskOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HDescribeVirtualDiskOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HDescribeVirtualDiskOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["vDiskName_"] = _hedvigpyc.HDescribeVirtualDiskOp_vDiskName__set
|
|
__swig_getmethods__["vDiskName_"] = _hedvigpyc.HDescribeVirtualDiskOp_vDiskName__get
|
|
if _newclass:vDiskName_ = _swig_property(_hedvigpyc.HDescribeVirtualDiskOp_vDiskName__get, _hedvigpyc.HDescribeVirtualDiskOp_vDiskName__set)
|
|
__swig_setmethods__["vDiskInfo_"] = _hedvigpyc.HDescribeVirtualDiskOp_vDiskInfo__set
|
|
__swig_getmethods__["vDiskInfo_"] = _hedvigpyc.HDescribeVirtualDiskOp_vDiskInfo__get
|
|
if _newclass:vDiskInfo_ = _swig_property(_hedvigpyc.HDescribeVirtualDiskOp_vDiskInfo__get, _hedvigpyc.HDescribeVirtualDiskOp_vDiskInfo__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HDescribeVirtualDiskOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HDescribeVirtualDiskOp
|
|
__del__ = lambda self : None;
|
|
HDescribeVirtualDiskOp_swigregister = _hedvigpyc.HDescribeVirtualDiskOp_swigregister
|
|
HDescribeVirtualDiskOp_swigregister(HDescribeVirtualDiskOp)
|
|
|
|
class HGetLunCinderOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HGetLunCinderOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HGetLunCinderOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["tgtHost_"] = _hedvigpyc.HGetLunCinderOp_tgtHost__set
|
|
__swig_getmethods__["tgtHost_"] = _hedvigpyc.HGetLunCinderOp_tgtHost__get
|
|
if _newclass:tgtHost_ = _swig_property(_hedvigpyc.HGetLunCinderOp_tgtHost__get, _hedvigpyc.HGetLunCinderOp_tgtHost__set)
|
|
__swig_setmethods__["tgtPort_"] = _hedvigpyc.HGetLunCinderOp_tgtPort__set
|
|
__swig_getmethods__["tgtPort_"] = _hedvigpyc.HGetLunCinderOp_tgtPort__get
|
|
if _newclass:tgtPort_ = _swig_property(_hedvigpyc.HGetLunCinderOp_tgtPort__get, _hedvigpyc.HGetLunCinderOp_tgtPort__set)
|
|
__swig_setmethods__["vDiskName_"] = _hedvigpyc.HGetLunCinderOp_vDiskName__set
|
|
__swig_getmethods__["vDiskName_"] = _hedvigpyc.HGetLunCinderOp_vDiskName__get
|
|
if _newclass:vDiskName_ = _swig_property(_hedvigpyc.HGetLunCinderOp_vDiskName__get, _hedvigpyc.HGetLunCinderOp_vDiskName__set)
|
|
__swig_setmethods__["lunNumber_"] = _hedvigpyc.HGetLunCinderOp_lunNumber__set
|
|
__swig_getmethods__["lunNumber_"] = _hedvigpyc.HGetLunCinderOp_lunNumber__get
|
|
if _newclass:lunNumber_ = _swig_property(_hedvigpyc.HGetLunCinderOp_lunNumber__get, _hedvigpyc.HGetLunCinderOp_lunNumber__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HGetLunCinderOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HGetLunCinderOp
|
|
__del__ = lambda self : None;
|
|
HGetLunCinderOp_swigregister = _hedvigpyc.HGetLunCinderOp_swigregister
|
|
HGetLunCinderOp_swigregister(HGetLunCinderOp)
|
|
|
|
class HAddLunOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HAddLunOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HAddLunOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["tgtHost_"] = _hedvigpyc.HAddLunOp_tgtHost__set
|
|
__swig_getmethods__["tgtHost_"] = _hedvigpyc.HAddLunOp_tgtHost__get
|
|
if _newclass:tgtHost_ = _swig_property(_hedvigpyc.HAddLunOp_tgtHost__get, _hedvigpyc.HAddLunOp_tgtHost__set)
|
|
__swig_setmethods__["tgtPort_"] = _hedvigpyc.HAddLunOp_tgtPort__set
|
|
__swig_getmethods__["tgtPort_"] = _hedvigpyc.HAddLunOp_tgtPort__get
|
|
if _newclass:tgtPort_ = _swig_property(_hedvigpyc.HAddLunOp_tgtPort__get, _hedvigpyc.HAddLunOp_tgtPort__set)
|
|
__swig_setmethods__["vDiskInfo_"] = _hedvigpyc.HAddLunOp_vDiskInfo__set
|
|
__swig_getmethods__["vDiskInfo_"] = _hedvigpyc.HAddLunOp_vDiskInfo__get
|
|
if _newclass:vDiskInfo_ = _swig_property(_hedvigpyc.HAddLunOp_vDiskInfo__get, _hedvigpyc.HAddLunOp_vDiskInfo__set)
|
|
__swig_setmethods__["lunNumber_"] = _hedvigpyc.HAddLunOp_lunNumber__set
|
|
__swig_getmethods__["lunNumber_"] = _hedvigpyc.HAddLunOp_lunNumber__get
|
|
if _newclass:lunNumber_ = _swig_property(_hedvigpyc.HAddLunOp_lunNumber__get, _hedvigpyc.HAddLunOp_lunNumber__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HAddLunOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HAddLunOp
|
|
__del__ = lambda self : None;
|
|
HAddLunOp_swigregister = _hedvigpyc.HAddLunOp_swigregister
|
|
HAddLunOp_swigregister(HAddLunOp)
|
|
|
|
class HDeleteLunOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HDeleteLunOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HDeleteLunOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["tgtHost_"] = _hedvigpyc.HDeleteLunOp_tgtHost__set
|
|
__swig_getmethods__["tgtHost_"] = _hedvigpyc.HDeleteLunOp_tgtHost__get
|
|
if _newclass:tgtHost_ = _swig_property(_hedvigpyc.HDeleteLunOp_tgtHost__get, _hedvigpyc.HDeleteLunOp_tgtHost__set)
|
|
__swig_setmethods__["tgtPort_"] = _hedvigpyc.HDeleteLunOp_tgtPort__set
|
|
__swig_getmethods__["tgtPort_"] = _hedvigpyc.HDeleteLunOp_tgtPort__get
|
|
if _newclass:tgtPort_ = _swig_property(_hedvigpyc.HDeleteLunOp_tgtPort__get, _hedvigpyc.HDeleteLunOp_tgtPort__set)
|
|
__swig_setmethods__["vDiskName_"] = _hedvigpyc.HDeleteLunOp_vDiskName__set
|
|
__swig_getmethods__["vDiskName_"] = _hedvigpyc.HDeleteLunOp_vDiskName__get
|
|
if _newclass:vDiskName_ = _swig_property(_hedvigpyc.HDeleteLunOp_vDiskName__get, _hedvigpyc.HDeleteLunOp_vDiskName__set)
|
|
__swig_setmethods__["lunNumber_"] = _hedvigpyc.HDeleteLunOp_lunNumber__set
|
|
__swig_getmethods__["lunNumber_"] = _hedvigpyc.HDeleteLunOp_lunNumber__get
|
|
if _newclass:lunNumber_ = _swig_property(_hedvigpyc.HDeleteLunOp_lunNumber__get, _hedvigpyc.HDeleteLunOp_lunNumber__set)
|
|
__swig_setmethods__["result_"] = _hedvigpyc.HDeleteLunOp_result__set
|
|
__swig_getmethods__["result_"] = _hedvigpyc.HDeleteLunOp_result__get
|
|
if _newclass:result_ = _swig_property(_hedvigpyc.HDeleteLunOp_result__get, _hedvigpyc.HDeleteLunOp_result__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HDeleteLunOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HDeleteLunOp
|
|
__del__ = lambda self : None;
|
|
HDeleteLunOp_swigregister = _hedvigpyc.HDeleteLunOp_swigregister
|
|
HDeleteLunOp_swigregister(HDeleteLunOp)
|
|
|
|
class HAddAccessOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HAddAccessOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HAddAccessOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["tgtHost_"] = _hedvigpyc.HAddAccessOp_tgtHost__set
|
|
__swig_getmethods__["tgtHost_"] = _hedvigpyc.HAddAccessOp_tgtHost__get
|
|
if _newclass:tgtHost_ = _swig_property(_hedvigpyc.HAddAccessOp_tgtHost__get, _hedvigpyc.HAddAccessOp_tgtHost__set)
|
|
__swig_setmethods__["tgtPort_"] = _hedvigpyc.HAddAccessOp_tgtPort__set
|
|
__swig_getmethods__["tgtPort_"] = _hedvigpyc.HAddAccessOp_tgtPort__get
|
|
if _newclass:tgtPort_ = _swig_property(_hedvigpyc.HAddAccessOp_tgtPort__get, _hedvigpyc.HAddAccessOp_tgtPort__set)
|
|
__swig_setmethods__["lunNumber_"] = _hedvigpyc.HAddAccessOp_lunNumber__set
|
|
__swig_getmethods__["lunNumber_"] = _hedvigpyc.HAddAccessOp_lunNumber__get
|
|
if _newclass:lunNumber_ = _swig_property(_hedvigpyc.HAddAccessOp_lunNumber__get, _hedvigpyc.HAddAccessOp_lunNumber__set)
|
|
__swig_setmethods__["Ip_"] = _hedvigpyc.HAddAccessOp_Ip__set
|
|
__swig_getmethods__["Ip_"] = _hedvigpyc.HAddAccessOp_Ip__get
|
|
if _newclass:Ip_ = _swig_property(_hedvigpyc.HAddAccessOp_Ip__get, _hedvigpyc.HAddAccessOp_Ip__set)
|
|
__swig_setmethods__["result_"] = _hedvigpyc.HAddAccessOp_result__set
|
|
__swig_getmethods__["result_"] = _hedvigpyc.HAddAccessOp_result__get
|
|
if _newclass:result_ = _swig_property(_hedvigpyc.HAddAccessOp_result__get, _hedvigpyc.HAddAccessOp_result__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HAddAccessOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HAddAccessOp
|
|
__del__ = lambda self : None;
|
|
HAddAccessOp_swigregister = _hedvigpyc.HAddAccessOp_swigregister
|
|
HAddAccessOp_swigregister(HAddAccessOp)
|
|
|
|
class HSnapshotFromTgtOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HSnapshotFromTgtOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HSnapshotFromTgtOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["tgtHost_"] = _hedvigpyc.HSnapshotFromTgtOp_tgtHost__set
|
|
__swig_getmethods__["tgtHost_"] = _hedvigpyc.HSnapshotFromTgtOp_tgtHost__get
|
|
if _newclass:tgtHost_ = _swig_property(_hedvigpyc.HSnapshotFromTgtOp_tgtHost__get, _hedvigpyc.HSnapshotFromTgtOp_tgtHost__set)
|
|
__swig_setmethods__["tgtPort_"] = _hedvigpyc.HSnapshotFromTgtOp_tgtPort__set
|
|
__swig_getmethods__["tgtPort_"] = _hedvigpyc.HSnapshotFromTgtOp_tgtPort__get
|
|
if _newclass:tgtPort_ = _swig_property(_hedvigpyc.HSnapshotFromTgtOp_tgtPort__get, _hedvigpyc.HSnapshotFromTgtOp_tgtPort__set)
|
|
__swig_setmethods__["vDiskName_"] = _hedvigpyc.HSnapshotFromTgtOp_vDiskName__set
|
|
__swig_getmethods__["vDiskName_"] = _hedvigpyc.HSnapshotFromTgtOp_vDiskName__get
|
|
if _newclass:vDiskName_ = _swig_property(_hedvigpyc.HSnapshotFromTgtOp_vDiskName__get, _hedvigpyc.HSnapshotFromTgtOp_vDiskName__set)
|
|
__swig_setmethods__["snapshot_"] = _hedvigpyc.HSnapshotFromTgtOp_snapshot__set
|
|
__swig_getmethods__["snapshot_"] = _hedvigpyc.HSnapshotFromTgtOp_snapshot__get
|
|
if _newclass:snapshot_ = _swig_property(_hedvigpyc.HSnapshotFromTgtOp_snapshot__get, _hedvigpyc.HSnapshotFromTgtOp_snapshot__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HSnapshotFromTgtOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HSnapshotFromTgtOp
|
|
__del__ = lambda self : None;
|
|
HSnapshotFromTgtOp_swigregister = _hedvigpyc.HSnapshotFromTgtOp_swigregister
|
|
HSnapshotFromTgtOp_swigregister(HSnapshotFromTgtOp)
|
|
|
|
class HSnapshotOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HSnapshotOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HSnapshotOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["vDiskName_"] = _hedvigpyc.HSnapshotOp_vDiskName__set
|
|
__swig_getmethods__["vDiskName_"] = _hedvigpyc.HSnapshotOp_vDiskName__get
|
|
if _newclass:vDiskName_ = _swig_property(_hedvigpyc.HSnapshotOp_vDiskName__get, _hedvigpyc.HSnapshotOp_vDiskName__set)
|
|
__swig_setmethods__["snapshotInfo_"] = _hedvigpyc.HSnapshotOp_snapshotInfo__set
|
|
__swig_getmethods__["snapshotInfo_"] = _hedvigpyc.HSnapshotOp_snapshotInfo__get
|
|
if _newclass:snapshotInfo_ = _swig_property(_hedvigpyc.HSnapshotOp_snapshotInfo__get, _hedvigpyc.HSnapshotOp_snapshotInfo__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HSnapshotOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HSnapshotOp
|
|
__del__ = lambda self : None;
|
|
HSnapshotOp_swigregister = _hedvigpyc.HSnapshotOp_swigregister
|
|
HSnapshotOp_swigregister(HSnapshotOp)
|
|
|
|
class HDeleteSnapshotOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HDeleteSnapshotOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HDeleteSnapshotOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["snapshotName_"] = _hedvigpyc.HDeleteSnapshotOp_snapshotName__set
|
|
__swig_getmethods__["snapshotName_"] = _hedvigpyc.HDeleteSnapshotOp_snapshotName__get
|
|
if _newclass:snapshotName_ = _swig_property(_hedvigpyc.HDeleteSnapshotOp_snapshotName__get, _hedvigpyc.HDeleteSnapshotOp_snapshotName__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HDeleteSnapshotOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HDeleteSnapshotOp
|
|
__del__ = lambda self : None;
|
|
HDeleteSnapshotOp_swigregister = _hedvigpyc.HDeleteSnapshotOp_swigregister
|
|
HDeleteSnapshotOp_swigregister(HDeleteSnapshotOp)
|
|
|
|
class HCreateVirtualDiskOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HCreateVirtualDiskOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HCreateVirtualDiskOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["vDiskInfo_"] = _hedvigpyc.HCreateVirtualDiskOp_vDiskInfo__set
|
|
__swig_getmethods__["vDiskInfo_"] = _hedvigpyc.HCreateVirtualDiskOp_vDiskInfo__get
|
|
if _newclass:vDiskInfo_ = _swig_property(_hedvigpyc.HCreateVirtualDiskOp_vDiskInfo__get, _hedvigpyc.HCreateVirtualDiskOp_vDiskInfo__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HCreateVirtualDiskOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HCreateVirtualDiskOp
|
|
__del__ = lambda self : None;
|
|
HCreateVirtualDiskOp_swigregister = _hedvigpyc.HCreateVirtualDiskOp_swigregister
|
|
HCreateVirtualDiskOp_swigregister(HCreateVirtualDiskOp)
|
|
|
|
class HResizeVirtualDiskOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HResizeVirtualDiskOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HResizeVirtualDiskOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["vDiskInfo_"] = _hedvigpyc.HResizeVirtualDiskOp_vDiskInfo__set
|
|
__swig_getmethods__["vDiskInfo_"] = _hedvigpyc.HResizeVirtualDiskOp_vDiskInfo__get
|
|
if _newclass:vDiskInfo_ = _swig_property(_hedvigpyc.HResizeVirtualDiskOp_vDiskInfo__get, _hedvigpyc.HResizeVirtualDiskOp_vDiskInfo__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HResizeVirtualDiskOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HResizeVirtualDiskOp
|
|
__del__ = lambda self : None;
|
|
HResizeVirtualDiskOp_swigregister = _hedvigpyc.HResizeVirtualDiskOp_swigregister
|
|
HResizeVirtualDiskOp_swigregister(HResizeVirtualDiskOp)
|
|
|
|
class HDeleteVirtualDiskOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HDeleteVirtualDiskOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HDeleteVirtualDiskOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["vDiskName_"] = _hedvigpyc.HDeleteVirtualDiskOp_vDiskName__set
|
|
__swig_getmethods__["vDiskName_"] = _hedvigpyc.HDeleteVirtualDiskOp_vDiskName__get
|
|
if _newclass:vDiskName_ = _swig_property(_hedvigpyc.HDeleteVirtualDiskOp_vDiskName__get, _hedvigpyc.HDeleteVirtualDiskOp_vDiskName__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HDeleteVirtualDiskOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HDeleteVirtualDiskOp
|
|
__del__ = lambda self : None;
|
|
HDeleteVirtualDiskOp_swigregister = _hedvigpyc.HDeleteVirtualDiskOp_swigregister
|
|
HDeleteVirtualDiskOp_swigregister(HDeleteVirtualDiskOp)
|
|
|
|
class HGetIqnOp(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, HGetIqnOp, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, HGetIqnOp, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["hostname_"] = _hedvigpyc.HGetIqnOp_hostname__set
|
|
__swig_getmethods__["hostname_"] = _hedvigpyc.HGetIqnOp_hostname__get
|
|
if _newclass:hostname_ = _swig_property(_hedvigpyc.HGetIqnOp_hostname__get, _hedvigpyc.HGetIqnOp_hostname__set)
|
|
__swig_setmethods__["iqn_"] = _hedvigpyc.HGetIqnOp_iqn__set
|
|
__swig_getmethods__["iqn_"] = _hedvigpyc.HGetIqnOp_iqn__get
|
|
if _newclass:iqn_ = _swig_property(_hedvigpyc.HGetIqnOp_iqn__get, _hedvigpyc.HGetIqnOp_iqn__set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_HGetIqnOp()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_HGetIqnOp
|
|
__del__ = lambda self : None;
|
|
HGetIqnOp_swigregister = _hedvigpyc.HGetIqnOp_swigregister
|
|
HGetIqnOp_swigregister(HGetIqnOp)
|
|
|
|
class ObjectStoreType(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ObjectStoreType, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ObjectStoreType, name)
|
|
__repr__ = _swig_repr
|
|
OpenStack = _hedvigpyc.ObjectStoreType_OpenStack
|
|
S3 = _hedvigpyc.ObjectStoreType_S3
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_ObjectStoreType()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_ObjectStoreType
|
|
__del__ = lambda self : None;
|
|
ObjectStoreType_swigregister = _hedvigpyc.ObjectStoreType_swigregister
|
|
ObjectStoreType_swigregister(ObjectStoreType)
|
|
|
|
class ObjectStoreFilter(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ObjectStoreFilter, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ObjectStoreFilter, name)
|
|
__repr__ = _swig_repr
|
|
PREFIX = _hedvigpyc.ObjectStoreFilter_PREFIX
|
|
MAX_ENTRIES = _hedvigpyc.ObjectStoreFilter_MAX_ENTRIES
|
|
DIR_PATH = _hedvigpyc.ObjectStoreFilter_DIR_PATH
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_ObjectStoreFilter()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_ObjectStoreFilter
|
|
__del__ = lambda self : None;
|
|
ObjectStoreFilter_swigregister = _hedvigpyc.ObjectStoreFilter_swigregister
|
|
ObjectStoreFilter_swigregister(ObjectStoreFilter)
|
|
|
|
class DiskResidence(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, DiskResidence, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, DiskResidence, name)
|
|
__repr__ = _swig_repr
|
|
Flash = _hedvigpyc.DiskResidence_Flash
|
|
HDD = _hedvigpyc.DiskResidence_HDD
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_DiskResidence()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_DiskResidence
|
|
__del__ = lambda self : None;
|
|
DiskResidence_swigregister = _hedvigpyc.DiskResidence_swigregister
|
|
DiskResidence_swigregister(DiskResidence)
|
|
|
|
class DiskType(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, DiskType, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, DiskType, name)
|
|
__repr__ = _swig_repr
|
|
BLOCK = _hedvigpyc.DiskType_BLOCK
|
|
NFS_MASTER_DISK = _hedvigpyc.DiskType_NFS_MASTER_DISK
|
|
NFS_CHILD_DISK = _hedvigpyc.DiskType_NFS_CHILD_DISK
|
|
OBJECT_STORE_DISK = _hedvigpyc.DiskType_OBJECT_STORE_DISK
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_DiskType()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_DiskType
|
|
__del__ = lambda self : None;
|
|
DiskType_swigregister = _hedvigpyc.DiskType_swigregister
|
|
DiskType_swigregister(DiskType)
|
|
cvar = _hedvigpyc.cvar
|
|
_DiskResidence_VALUES_TO_NAMES = cvar._DiskResidence_VALUES_TO_NAMES
|
|
|
|
class ReplicationPolicy(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ReplicationPolicy, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ReplicationPolicy, name)
|
|
__repr__ = _swig_repr
|
|
Agnostic = _hedvigpyc.ReplicationPolicy_Agnostic
|
|
RackAware = _hedvigpyc.ReplicationPolicy_RackAware
|
|
DataCenterAware = _hedvigpyc.ReplicationPolicy_DataCenterAware
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_ReplicationPolicy()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_ReplicationPolicy
|
|
__del__ = lambda self : None;
|
|
ReplicationPolicy_swigregister = _hedvigpyc.ReplicationPolicy_swigregister
|
|
ReplicationPolicy_swigregister(ReplicationPolicy)
|
|
_DiskType_VALUES_TO_NAMES = cvar._DiskType_VALUES_TO_NAMES
|
|
|
|
class Consistency(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, Consistency, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, Consistency, name)
|
|
__repr__ = _swig_repr
|
|
WEAK = _hedvigpyc.Consistency_WEAK
|
|
STRONG = _hedvigpyc.Consistency_STRONG
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_Consistency()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_Consistency
|
|
__del__ = lambda self : None;
|
|
Consistency_swigregister = _hedvigpyc.Consistency_swigregister
|
|
Consistency_swigregister(Consistency)
|
|
_ReplicationPolicy_VALUES_TO_NAMES = cvar._ReplicationPolicy_VALUES_TO_NAMES
|
|
|
|
class CloudProvider(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, CloudProvider, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, CloudProvider, name)
|
|
__repr__ = _swig_repr
|
|
NONE = _hedvigpyc.CloudProvider_NONE
|
|
AMAZON = _hedvigpyc.CloudProvider_AMAZON
|
|
GOOGLE = _hedvigpyc.CloudProvider_GOOGLE
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_CloudProvider()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_CloudProvider
|
|
__del__ = lambda self : None;
|
|
CloudProvider_swigregister = _hedvigpyc.CloudProvider_swigregister
|
|
CloudProvider_swigregister(CloudProvider)
|
|
_Consistency_VALUES_TO_NAMES = cvar._Consistency_VALUES_TO_NAMES
|
|
|
|
class TypeOfClone(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, TypeOfClone, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, TypeOfClone, name)
|
|
__repr__ = _swig_repr
|
|
Deep = _hedvigpyc.TypeOfClone_Deep
|
|
Shallow = _hedvigpyc.TypeOfClone_Shallow
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_TypeOfClone()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_TypeOfClone
|
|
__del__ = lambda self : None;
|
|
TypeOfClone_swigregister = _hedvigpyc.TypeOfClone_swigregister
|
|
TypeOfClone_swigregister(TypeOfClone)
|
|
_CloudProvider_VALUES_TO_NAMES = cvar._CloudProvider_VALUES_TO_NAMES
|
|
|
|
class _CloneInfo__isset(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, _CloneInfo__isset, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, _CloneInfo__isset, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _hedvigpyc.new__CloneInfo__isset()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["baseDisk"] = _hedvigpyc._CloneInfo__isset_baseDisk_set
|
|
__swig_getmethods__["baseDisk"] = _hedvigpyc._CloneInfo__isset_baseDisk_get
|
|
if _newclass:baseDisk = _swig_property(_hedvigpyc._CloneInfo__isset_baseDisk_get, _hedvigpyc._CloneInfo__isset_baseDisk_set)
|
|
__swig_setmethods__["snapshot"] = _hedvigpyc._CloneInfo__isset_snapshot_set
|
|
__swig_getmethods__["snapshot"] = _hedvigpyc._CloneInfo__isset_snapshot_get
|
|
if _newclass:snapshot = _swig_property(_hedvigpyc._CloneInfo__isset_snapshot_get, _hedvigpyc._CloneInfo__isset_snapshot_set)
|
|
__swig_setmethods__["baseVersion"] = _hedvigpyc._CloneInfo__isset_baseVersion_set
|
|
__swig_getmethods__["baseVersion"] = _hedvigpyc._CloneInfo__isset_baseVersion_get
|
|
if _newclass:baseVersion = _swig_property(_hedvigpyc._CloneInfo__isset_baseVersion_get, _hedvigpyc._CloneInfo__isset_baseVersion_set)
|
|
__swig_setmethods__["typeOfClone"] = _hedvigpyc._CloneInfo__isset_typeOfClone_set
|
|
__swig_getmethods__["typeOfClone"] = _hedvigpyc._CloneInfo__isset_typeOfClone_get
|
|
if _newclass:typeOfClone = _swig_property(_hedvigpyc._CloneInfo__isset_typeOfClone_get, _hedvigpyc._CloneInfo__isset_typeOfClone_set)
|
|
__swig_destroy__ = _hedvigpyc.delete__CloneInfo__isset
|
|
__del__ = lambda self : None;
|
|
_CloneInfo__isset_swigregister = _hedvigpyc._CloneInfo__isset_swigregister
|
|
_CloneInfo__isset_swigregister(_CloneInfo__isset)
|
|
_TypeOfClone_VALUES_TO_NAMES = cvar._TypeOfClone_VALUES_TO_NAMES
|
|
|
|
class CloneInfo(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, CloneInfo, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, CloneInfo, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["baseDisk"] = _hedvigpyc.CloneInfo_baseDisk_set
|
|
__swig_getmethods__["baseDisk"] = _hedvigpyc.CloneInfo_baseDisk_get
|
|
if _newclass:baseDisk = _swig_property(_hedvigpyc.CloneInfo_baseDisk_get, _hedvigpyc.CloneInfo_baseDisk_set)
|
|
__swig_setmethods__["snapshot"] = _hedvigpyc.CloneInfo_snapshot_set
|
|
__swig_getmethods__["snapshot"] = _hedvigpyc.CloneInfo_snapshot_get
|
|
if _newclass:snapshot = _swig_property(_hedvigpyc.CloneInfo_snapshot_get, _hedvigpyc.CloneInfo_snapshot_set)
|
|
__swig_setmethods__["baseVersion"] = _hedvigpyc.CloneInfo_baseVersion_set
|
|
__swig_getmethods__["baseVersion"] = _hedvigpyc.CloneInfo_baseVersion_get
|
|
if _newclass:baseVersion = _swig_property(_hedvigpyc.CloneInfo_baseVersion_get, _hedvigpyc.CloneInfo_baseVersion_set)
|
|
__swig_setmethods__["typeOfClone"] = _hedvigpyc.CloneInfo_typeOfClone_set
|
|
__swig_getmethods__["typeOfClone"] = _hedvigpyc.CloneInfo_typeOfClone_get
|
|
if _newclass:typeOfClone = _swig_property(_hedvigpyc.CloneInfo_typeOfClone_get, _hedvigpyc.CloneInfo_typeOfClone_set)
|
|
__swig_setmethods__["__isset"] = _hedvigpyc.CloneInfo___isset_set
|
|
__swig_getmethods__["__isset"] = _hedvigpyc.CloneInfo___isset_get
|
|
if _newclass:__isset = _swig_property(_hedvigpyc.CloneInfo___isset_get, _hedvigpyc.CloneInfo___isset_set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_CloneInfo()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_CloneInfo
|
|
__del__ = lambda self : None;
|
|
CloneInfo_swigregister = _hedvigpyc.CloneInfo_swigregister
|
|
CloneInfo_swigregister(CloneInfo)
|
|
|
|
class _ReplicationPolicyInfo__isset(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, _ReplicationPolicyInfo__isset, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, _ReplicationPolicyInfo__isset, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _hedvigpyc.new__ReplicationPolicyInfo__isset()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["dataCenterNames"] = _hedvigpyc._ReplicationPolicyInfo__isset_dataCenterNames_set
|
|
__swig_getmethods__["dataCenterNames"] = _hedvigpyc._ReplicationPolicyInfo__isset_dataCenterNames_get
|
|
if _newclass:dataCenterNames = _swig_property(_hedvigpyc._ReplicationPolicyInfo__isset_dataCenterNames_get, _hedvigpyc._ReplicationPolicyInfo__isset_dataCenterNames_set)
|
|
__swig_destroy__ = _hedvigpyc.delete__ReplicationPolicyInfo__isset
|
|
__del__ = lambda self : None;
|
|
_ReplicationPolicyInfo__isset_swigregister = _hedvigpyc._ReplicationPolicyInfo__isset_swigregister
|
|
_ReplicationPolicyInfo__isset_swigregister(_ReplicationPolicyInfo__isset)
|
|
|
|
class ReplicationPolicyInfo(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, ReplicationPolicyInfo, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, ReplicationPolicyInfo, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["dataCenterNames"] = _hedvigpyc.ReplicationPolicyInfo_dataCenterNames_set
|
|
__swig_getmethods__["dataCenterNames"] = _hedvigpyc.ReplicationPolicyInfo_dataCenterNames_get
|
|
if _newclass:dataCenterNames = _swig_property(_hedvigpyc.ReplicationPolicyInfo_dataCenterNames_get, _hedvigpyc.ReplicationPolicyInfo_dataCenterNames_set)
|
|
__swig_setmethods__["__isset"] = _hedvigpyc.ReplicationPolicyInfo___isset_set
|
|
__swig_getmethods__["__isset"] = _hedvigpyc.ReplicationPolicyInfo___isset_get
|
|
if _newclass:__isset = _swig_property(_hedvigpyc.ReplicationPolicyInfo___isset_get, _hedvigpyc.ReplicationPolicyInfo___isset_set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_ReplicationPolicyInfo()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_ReplicationPolicyInfo
|
|
__del__ = lambda self : None;
|
|
ReplicationPolicyInfo_swigregister = _hedvigpyc.ReplicationPolicyInfo_swigregister
|
|
ReplicationPolicyInfo_swigregister(ReplicationPolicyInfo)
|
|
|
|
class _VDiskInfo__isset(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, _VDiskInfo__isset, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, _VDiskInfo__isset, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _hedvigpyc.new__VDiskInfo__isset()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["vDiskName"] = _hedvigpyc._VDiskInfo__isset_vDiskName_set
|
|
__swig_getmethods__["vDiskName"] = _hedvigpyc._VDiskInfo__isset_vDiskName_get
|
|
if _newclass:vDiskName = _swig_property(_hedvigpyc._VDiskInfo__isset_vDiskName_get, _hedvigpyc._VDiskInfo__isset_vDiskName_set)
|
|
__swig_setmethods__["createdBy"] = _hedvigpyc._VDiskInfo__isset_createdBy_set
|
|
__swig_getmethods__["createdBy"] = _hedvigpyc._VDiskInfo__isset_createdBy_get
|
|
if _newclass:createdBy = _swig_property(_hedvigpyc._VDiskInfo__isset_createdBy_get, _hedvigpyc._VDiskInfo__isset_createdBy_set)
|
|
__swig_setmethods__["size"] = _hedvigpyc._VDiskInfo__isset_size_set
|
|
__swig_getmethods__["size"] = _hedvigpyc._VDiskInfo__isset_size_get
|
|
if _newclass:size = _swig_property(_hedvigpyc._VDiskInfo__isset_size_get, _hedvigpyc._VDiskInfo__isset_size_set)
|
|
__swig_setmethods__["replicationFactor"] = _hedvigpyc._VDiskInfo__isset_replicationFactor_set
|
|
__swig_getmethods__["replicationFactor"] = _hedvigpyc._VDiskInfo__isset_replicationFactor_get
|
|
if _newclass:replicationFactor = _swig_property(_hedvigpyc._VDiskInfo__isset_replicationFactor_get, _hedvigpyc._VDiskInfo__isset_replicationFactor_set)
|
|
__swig_setmethods__["residence"] = _hedvigpyc._VDiskInfo__isset_residence_set
|
|
__swig_getmethods__["residence"] = _hedvigpyc._VDiskInfo__isset_residence_get
|
|
if _newclass:residence = _swig_property(_hedvigpyc._VDiskInfo__isset_residence_get, _hedvigpyc._VDiskInfo__isset_residence_set)
|
|
__swig_setmethods__["replicationPolicy"] = _hedvigpyc._VDiskInfo__isset_replicationPolicy_set
|
|
__swig_getmethods__["replicationPolicy"] = _hedvigpyc._VDiskInfo__isset_replicationPolicy_get
|
|
if _newclass:replicationPolicy = _swig_property(_hedvigpyc._VDiskInfo__isset_replicationPolicy_get, _hedvigpyc._VDiskInfo__isset_replicationPolicy_set)
|
|
__swig_setmethods__["mntLocation"] = _hedvigpyc._VDiskInfo__isset_mntLocation_set
|
|
__swig_getmethods__["mntLocation"] = _hedvigpyc._VDiskInfo__isset_mntLocation_get
|
|
if _newclass:mntLocation = _swig_property(_hedvigpyc._VDiskInfo__isset_mntLocation_get, _hedvigpyc._VDiskInfo__isset_mntLocation_set)
|
|
__swig_setmethods__["description"] = _hedvigpyc._VDiskInfo__isset_description_set
|
|
__swig_getmethods__["description"] = _hedvigpyc._VDiskInfo__isset_description_get
|
|
if _newclass:description = _swig_property(_hedvigpyc._VDiskInfo__isset_description_get, _hedvigpyc._VDiskInfo__isset_description_set)
|
|
__swig_setmethods__["generationNbr"] = _hedvigpyc._VDiskInfo__isset_generationNbr_set
|
|
__swig_getmethods__["generationNbr"] = _hedvigpyc._VDiskInfo__isset_generationNbr_get
|
|
if _newclass:generationNbr = _swig_property(_hedvigpyc._VDiskInfo__isset_generationNbr_get, _hedvigpyc._VDiskInfo__isset_generationNbr_set)
|
|
__swig_setmethods__["blockSize"] = _hedvigpyc._VDiskInfo__isset_blockSize_set
|
|
__swig_getmethods__["blockSize"] = _hedvigpyc._VDiskInfo__isset_blockSize_get
|
|
if _newclass:blockSize = _swig_property(_hedvigpyc._VDiskInfo__isset_blockSize_get, _hedvigpyc._VDiskInfo__isset_blockSize_set)
|
|
__swig_setmethods__["clusteredfilesystem"] = _hedvigpyc._VDiskInfo__isset_clusteredfilesystem_set
|
|
__swig_getmethods__["clusteredfilesystem"] = _hedvigpyc._VDiskInfo__isset_clusteredfilesystem_get
|
|
if _newclass:clusteredfilesystem = _swig_property(_hedvigpyc._VDiskInfo__isset_clusteredfilesystem_get, _hedvigpyc._VDiskInfo__isset_clusteredfilesystem_set)
|
|
__swig_setmethods__["versionCounter"] = _hedvigpyc._VDiskInfo__isset_versionCounter_set
|
|
__swig_getmethods__["versionCounter"] = _hedvigpyc._VDiskInfo__isset_versionCounter_get
|
|
if _newclass:versionCounter = _swig_property(_hedvigpyc._VDiskInfo__isset_versionCounter_get, _hedvigpyc._VDiskInfo__isset_versionCounter_set)
|
|
__swig_setmethods__["vTreeBuffer"] = _hedvigpyc._VDiskInfo__isset_vTreeBuffer_set
|
|
__swig_getmethods__["vTreeBuffer"] = _hedvigpyc._VDiskInfo__isset_vTreeBuffer_get
|
|
if _newclass:vTreeBuffer = _swig_property(_hedvigpyc._VDiskInfo__isset_vTreeBuffer_get, _hedvigpyc._VDiskInfo__isset_vTreeBuffer_set)
|
|
__swig_setmethods__["cloneInfo"] = _hedvigpyc._VDiskInfo__isset_cloneInfo_set
|
|
__swig_getmethods__["cloneInfo"] = _hedvigpyc._VDiskInfo__isset_cloneInfo_get
|
|
if _newclass:cloneInfo = _swig_property(_hedvigpyc._VDiskInfo__isset_cloneInfo_get, _hedvigpyc._VDiskInfo__isset_cloneInfo_set)
|
|
__swig_setmethods__["isClone"] = _hedvigpyc._VDiskInfo__isset_isClone_set
|
|
__swig_getmethods__["isClone"] = _hedvigpyc._VDiskInfo__isset_isClone_get
|
|
if _newclass:isClone = _swig_property(_hedvigpyc._VDiskInfo__isset_isClone_get, _hedvigpyc._VDiskInfo__isset_isClone_set)
|
|
__swig_setmethods__["replicationPolicyInfo"] = _hedvigpyc._VDiskInfo__isset_replicationPolicyInfo_set
|
|
__swig_getmethods__["replicationPolicyInfo"] = _hedvigpyc._VDiskInfo__isset_replicationPolicyInfo_get
|
|
if _newclass:replicationPolicyInfo = _swig_property(_hedvigpyc._VDiskInfo__isset_replicationPolicyInfo_get, _hedvigpyc._VDiskInfo__isset_replicationPolicyInfo_set)
|
|
__swig_setmethods__["targetLocations"] = _hedvigpyc._VDiskInfo__isset_targetLocations_set
|
|
__swig_getmethods__["targetLocations"] = _hedvigpyc._VDiskInfo__isset_targetLocations_get
|
|
if _newclass:targetLocations = _swig_property(_hedvigpyc._VDiskInfo__isset_targetLocations_get, _hedvigpyc._VDiskInfo__isset_targetLocations_set)
|
|
__swig_setmethods__["scsisn"] = _hedvigpyc._VDiskInfo__isset_scsisn_set
|
|
__swig_getmethods__["scsisn"] = _hedvigpyc._VDiskInfo__isset_scsisn_get
|
|
if _newclass:scsisn = _swig_property(_hedvigpyc._VDiskInfo__isset_scsisn_get, _hedvigpyc._VDiskInfo__isset_scsisn_set)
|
|
__swig_setmethods__["exportedBlockSize"] = _hedvigpyc._VDiskInfo__isset_exportedBlockSize_set
|
|
__swig_getmethods__["exportedBlockSize"] = _hedvigpyc._VDiskInfo__isset_exportedBlockSize_get
|
|
if _newclass:exportedBlockSize = _swig_property(_hedvigpyc._VDiskInfo__isset_exportedBlockSize_get, _hedvigpyc._VDiskInfo__isset_exportedBlockSize_set)
|
|
__swig_setmethods__["cacheEnable"] = _hedvigpyc._VDiskInfo__isset_cacheEnable_set
|
|
__swig_getmethods__["cacheEnable"] = _hedvigpyc._VDiskInfo__isset_cacheEnable_get
|
|
if _newclass:cacheEnable = _swig_property(_hedvigpyc._VDiskInfo__isset_cacheEnable_get, _hedvigpyc._VDiskInfo__isset_cacheEnable_set)
|
|
__swig_setmethods__["diskType"] = _hedvigpyc._VDiskInfo__isset_diskType_set
|
|
__swig_getmethods__["diskType"] = _hedvigpyc._VDiskInfo__isset_diskType_get
|
|
if _newclass:diskType = _swig_property(_hedvigpyc._VDiskInfo__isset_diskType_get, _hedvigpyc._VDiskInfo__isset_diskType_set)
|
|
__swig_setmethods__["immutable"] = _hedvigpyc._VDiskInfo__isset_immutable_set
|
|
__swig_getmethods__["immutable"] = _hedvigpyc._VDiskInfo__isset_immutable_get
|
|
if _newclass:immutable = _swig_property(_hedvigpyc._VDiskInfo__isset_immutable_get, _hedvigpyc._VDiskInfo__isset_immutable_set)
|
|
__swig_setmethods__["compressed"] = _hedvigpyc._VDiskInfo__isset_compressed_set
|
|
__swig_getmethods__["compressed"] = _hedvigpyc._VDiskInfo__isset_compressed_get
|
|
if _newclass:compressed = _swig_property(_hedvigpyc._VDiskInfo__isset_compressed_get, _hedvigpyc._VDiskInfo__isset_compressed_set)
|
|
__swig_setmethods__["dedup"] = _hedvigpyc._VDiskInfo__isset_dedup_set
|
|
__swig_getmethods__["dedup"] = _hedvigpyc._VDiskInfo__isset_dedup_get
|
|
if _newclass:dedup = _swig_property(_hedvigpyc._VDiskInfo__isset_dedup_get, _hedvigpyc._VDiskInfo__isset_dedup_set)
|
|
__swig_setmethods__["dedupBuckets"] = _hedvigpyc._VDiskInfo__isset_dedupBuckets_set
|
|
__swig_getmethods__["dedupBuckets"] = _hedvigpyc._VDiskInfo__isset_dedupBuckets_get
|
|
if _newclass:dedupBuckets = _swig_property(_hedvigpyc._VDiskInfo__isset_dedupBuckets_get, _hedvigpyc._VDiskInfo__isset_dedupBuckets_set)
|
|
__swig_setmethods__["cloudEnabled"] = _hedvigpyc._VDiskInfo__isset_cloudEnabled_set
|
|
__swig_getmethods__["cloudEnabled"] = _hedvigpyc._VDiskInfo__isset_cloudEnabled_get
|
|
if _newclass:cloudEnabled = _swig_property(_hedvigpyc._VDiskInfo__isset_cloudEnabled_get, _hedvigpyc._VDiskInfo__isset_cloudEnabled_set)
|
|
__swig_setmethods__["cloudProvider"] = _hedvigpyc._VDiskInfo__isset_cloudProvider_set
|
|
__swig_getmethods__["cloudProvider"] = _hedvigpyc._VDiskInfo__isset_cloudProvider_get
|
|
if _newclass:cloudProvider = _swig_property(_hedvigpyc._VDiskInfo__isset_cloudProvider_get, _hedvigpyc._VDiskInfo__isset_cloudProvider_set)
|
|
__swig_setmethods__["masterVDiskName"] = _hedvigpyc._VDiskInfo__isset_masterVDiskName_set
|
|
__swig_getmethods__["masterVDiskName"] = _hedvigpyc._VDiskInfo__isset_masterVDiskName_get
|
|
if _newclass:masterVDiskName = _swig_property(_hedvigpyc._VDiskInfo__isset_masterVDiskName_get, _hedvigpyc._VDiskInfo__isset_masterVDiskName_set)
|
|
__swig_destroy__ = _hedvigpyc.delete__VDiskInfo__isset
|
|
__del__ = lambda self : None;
|
|
_VDiskInfo__isset_swigregister = _hedvigpyc._VDiskInfo__isset_swigregister
|
|
_VDiskInfo__isset_swigregister(_VDiskInfo__isset)
|
|
|
|
class VDiskInfo(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, VDiskInfo, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, VDiskInfo, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["vDiskName"] = _hedvigpyc.VDiskInfo_vDiskName_set
|
|
__swig_getmethods__["vDiskName"] = _hedvigpyc.VDiskInfo_vDiskName_get
|
|
if _newclass:vDiskName = _swig_property(_hedvigpyc.VDiskInfo_vDiskName_get, _hedvigpyc.VDiskInfo_vDiskName_set)
|
|
__swig_setmethods__["createdBy"] = _hedvigpyc.VDiskInfo_createdBy_set
|
|
__swig_getmethods__["createdBy"] = _hedvigpyc.VDiskInfo_createdBy_get
|
|
if _newclass:createdBy = _swig_property(_hedvigpyc.VDiskInfo_createdBy_get, _hedvigpyc.VDiskInfo_createdBy_set)
|
|
__swig_setmethods__["size"] = _hedvigpyc.VDiskInfo_size_set
|
|
__swig_getmethods__["size"] = _hedvigpyc.VDiskInfo_size_get
|
|
if _newclass:size = _swig_property(_hedvigpyc.VDiskInfo_size_get, _hedvigpyc.VDiskInfo_size_set)
|
|
__swig_setmethods__["replicationFactor"] = _hedvigpyc.VDiskInfo_replicationFactor_set
|
|
__swig_getmethods__["replicationFactor"] = _hedvigpyc.VDiskInfo_replicationFactor_get
|
|
if _newclass:replicationFactor = _swig_property(_hedvigpyc.VDiskInfo_replicationFactor_get, _hedvigpyc.VDiskInfo_replicationFactor_set)
|
|
__swig_setmethods__["residence"] = _hedvigpyc.VDiskInfo_residence_set
|
|
__swig_getmethods__["residence"] = _hedvigpyc.VDiskInfo_residence_get
|
|
if _newclass:residence = _swig_property(_hedvigpyc.VDiskInfo_residence_get, _hedvigpyc.VDiskInfo_residence_set)
|
|
__swig_setmethods__["replicationPolicy"] = _hedvigpyc.VDiskInfo_replicationPolicy_set
|
|
__swig_getmethods__["replicationPolicy"] = _hedvigpyc.VDiskInfo_replicationPolicy_get
|
|
if _newclass:replicationPolicy = _swig_property(_hedvigpyc.VDiskInfo_replicationPolicy_get, _hedvigpyc.VDiskInfo_replicationPolicy_set)
|
|
__swig_setmethods__["mntLocation"] = _hedvigpyc.VDiskInfo_mntLocation_set
|
|
__swig_getmethods__["mntLocation"] = _hedvigpyc.VDiskInfo_mntLocation_get
|
|
if _newclass:mntLocation = _swig_property(_hedvigpyc.VDiskInfo_mntLocation_get, _hedvigpyc.VDiskInfo_mntLocation_set)
|
|
__swig_setmethods__["description"] = _hedvigpyc.VDiskInfo_description_set
|
|
__swig_getmethods__["description"] = _hedvigpyc.VDiskInfo_description_get
|
|
if _newclass:description = _swig_property(_hedvigpyc.VDiskInfo_description_get, _hedvigpyc.VDiskInfo_description_set)
|
|
__swig_setmethods__["generationNbr"] = _hedvigpyc.VDiskInfo_generationNbr_set
|
|
__swig_getmethods__["generationNbr"] = _hedvigpyc.VDiskInfo_generationNbr_get
|
|
if _newclass:generationNbr = _swig_property(_hedvigpyc.VDiskInfo_generationNbr_get, _hedvigpyc.VDiskInfo_generationNbr_set)
|
|
__swig_setmethods__["blockSize"] = _hedvigpyc.VDiskInfo_blockSize_set
|
|
__swig_getmethods__["blockSize"] = _hedvigpyc.VDiskInfo_blockSize_get
|
|
if _newclass:blockSize = _swig_property(_hedvigpyc.VDiskInfo_blockSize_get, _hedvigpyc.VDiskInfo_blockSize_set)
|
|
__swig_setmethods__["clusteredfilesystem"] = _hedvigpyc.VDiskInfo_clusteredfilesystem_set
|
|
__swig_getmethods__["clusteredfilesystem"] = _hedvigpyc.VDiskInfo_clusteredfilesystem_get
|
|
if _newclass:clusteredfilesystem = _swig_property(_hedvigpyc.VDiskInfo_clusteredfilesystem_get, _hedvigpyc.VDiskInfo_clusteredfilesystem_set)
|
|
__swig_setmethods__["versionCounter"] = _hedvigpyc.VDiskInfo_versionCounter_set
|
|
__swig_getmethods__["versionCounter"] = _hedvigpyc.VDiskInfo_versionCounter_get
|
|
if _newclass:versionCounter = _swig_property(_hedvigpyc.VDiskInfo_versionCounter_get, _hedvigpyc.VDiskInfo_versionCounter_set)
|
|
__swig_setmethods__["vTreeBuffer"] = _hedvigpyc.VDiskInfo_vTreeBuffer_set
|
|
__swig_getmethods__["vTreeBuffer"] = _hedvigpyc.VDiskInfo_vTreeBuffer_get
|
|
if _newclass:vTreeBuffer = _swig_property(_hedvigpyc.VDiskInfo_vTreeBuffer_get, _hedvigpyc.VDiskInfo_vTreeBuffer_set)
|
|
__swig_setmethods__["cloneInfo"] = _hedvigpyc.VDiskInfo_cloneInfo_set
|
|
__swig_getmethods__["cloneInfo"] = _hedvigpyc.VDiskInfo_cloneInfo_get
|
|
if _newclass:cloneInfo = _swig_property(_hedvigpyc.VDiskInfo_cloneInfo_get, _hedvigpyc.VDiskInfo_cloneInfo_set)
|
|
__swig_setmethods__["isClone"] = _hedvigpyc.VDiskInfo_isClone_set
|
|
__swig_getmethods__["isClone"] = _hedvigpyc.VDiskInfo_isClone_get
|
|
if _newclass:isClone = _swig_property(_hedvigpyc.VDiskInfo_isClone_get, _hedvigpyc.VDiskInfo_isClone_set)
|
|
__swig_setmethods__["replicationPolicyInfo"] = _hedvigpyc.VDiskInfo_replicationPolicyInfo_set
|
|
__swig_getmethods__["replicationPolicyInfo"] = _hedvigpyc.VDiskInfo_replicationPolicyInfo_get
|
|
if _newclass:replicationPolicyInfo = _swig_property(_hedvigpyc.VDiskInfo_replicationPolicyInfo_get, _hedvigpyc.VDiskInfo_replicationPolicyInfo_set)
|
|
__swig_setmethods__["targetLocations"] = _hedvigpyc.VDiskInfo_targetLocations_set
|
|
__swig_getmethods__["targetLocations"] = _hedvigpyc.VDiskInfo_targetLocations_get
|
|
if _newclass:targetLocations = _swig_property(_hedvigpyc.VDiskInfo_targetLocations_get, _hedvigpyc.VDiskInfo_targetLocations_set)
|
|
__swig_setmethods__["scsisn"] = _hedvigpyc.VDiskInfo_scsisn_set
|
|
__swig_getmethods__["scsisn"] = _hedvigpyc.VDiskInfo_scsisn_get
|
|
if _newclass:scsisn = _swig_property(_hedvigpyc.VDiskInfo_scsisn_get, _hedvigpyc.VDiskInfo_scsisn_set)
|
|
__swig_setmethods__["exportedBlockSize"] = _hedvigpyc.VDiskInfo_exportedBlockSize_set
|
|
__swig_getmethods__["exportedBlockSize"] = _hedvigpyc.VDiskInfo_exportedBlockSize_get
|
|
if _newclass:exportedBlockSize = _swig_property(_hedvigpyc.VDiskInfo_exportedBlockSize_get, _hedvigpyc.VDiskInfo_exportedBlockSize_set)
|
|
__swig_setmethods__["cacheEnable"] = _hedvigpyc.VDiskInfo_cacheEnable_set
|
|
__swig_getmethods__["cacheEnable"] = _hedvigpyc.VDiskInfo_cacheEnable_get
|
|
if _newclass:cacheEnable = _swig_property(_hedvigpyc.VDiskInfo_cacheEnable_get, _hedvigpyc.VDiskInfo_cacheEnable_set)
|
|
__swig_setmethods__["diskType"] = _hedvigpyc.VDiskInfo_diskType_set
|
|
__swig_getmethods__["diskType"] = _hedvigpyc.VDiskInfo_diskType_get
|
|
if _newclass:diskType = _swig_property(_hedvigpyc.VDiskInfo_diskType_get, _hedvigpyc.VDiskInfo_diskType_set)
|
|
__swig_setmethods__["immutable"] = _hedvigpyc.VDiskInfo_immutable_set
|
|
__swig_getmethods__["immutable"] = _hedvigpyc.VDiskInfo_immutable_get
|
|
if _newclass:immutable = _swig_property(_hedvigpyc.VDiskInfo_immutable_get, _hedvigpyc.VDiskInfo_immutable_set)
|
|
__swig_setmethods__["compressed"] = _hedvigpyc.VDiskInfo_compressed_set
|
|
__swig_getmethods__["compressed"] = _hedvigpyc.VDiskInfo_compressed_get
|
|
if _newclass:compressed = _swig_property(_hedvigpyc.VDiskInfo_compressed_get, _hedvigpyc.VDiskInfo_compressed_set)
|
|
__swig_setmethods__["dedup"] = _hedvigpyc.VDiskInfo_dedup_set
|
|
__swig_getmethods__["dedup"] = _hedvigpyc.VDiskInfo_dedup_get
|
|
if _newclass:dedup = _swig_property(_hedvigpyc.VDiskInfo_dedup_get, _hedvigpyc.VDiskInfo_dedup_set)
|
|
__swig_setmethods__["dedupBuckets"] = _hedvigpyc.VDiskInfo_dedupBuckets_set
|
|
__swig_getmethods__["dedupBuckets"] = _hedvigpyc.VDiskInfo_dedupBuckets_get
|
|
if _newclass:dedupBuckets = _swig_property(_hedvigpyc.VDiskInfo_dedupBuckets_get, _hedvigpyc.VDiskInfo_dedupBuckets_set)
|
|
__swig_setmethods__["cloudEnabled"] = _hedvigpyc.VDiskInfo_cloudEnabled_set
|
|
__swig_getmethods__["cloudEnabled"] = _hedvigpyc.VDiskInfo_cloudEnabled_get
|
|
if _newclass:cloudEnabled = _swig_property(_hedvigpyc.VDiskInfo_cloudEnabled_get, _hedvigpyc.VDiskInfo_cloudEnabled_set)
|
|
__swig_setmethods__["cloudProvider"] = _hedvigpyc.VDiskInfo_cloudProvider_set
|
|
__swig_getmethods__["cloudProvider"] = _hedvigpyc.VDiskInfo_cloudProvider_get
|
|
if _newclass:cloudProvider = _swig_property(_hedvigpyc.VDiskInfo_cloudProvider_get, _hedvigpyc.VDiskInfo_cloudProvider_set)
|
|
__swig_setmethods__["masterVDiskName"] = _hedvigpyc.VDiskInfo_masterVDiskName_set
|
|
__swig_getmethods__["masterVDiskName"] = _hedvigpyc.VDiskInfo_masterVDiskName_get
|
|
if _newclass:masterVDiskName = _swig_property(_hedvigpyc.VDiskInfo_masterVDiskName_get, _hedvigpyc.VDiskInfo_masterVDiskName_set)
|
|
__swig_setmethods__["__isset"] = _hedvigpyc.VDiskInfo___isset_set
|
|
__swig_getmethods__["__isset"] = _hedvigpyc.VDiskInfo___isset_get
|
|
if _newclass:__isset = _swig_property(_hedvigpyc.VDiskInfo___isset_get, _hedvigpyc.VDiskInfo___isset_set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_VDiskInfo()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_VDiskInfo
|
|
__del__ = lambda self : None;
|
|
VDiskInfo_swigregister = _hedvigpyc.VDiskInfo_swigregister
|
|
VDiskInfo_swigregister(VDiskInfo)
|
|
|
|
class _SnapshotInfo__isset(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, _SnapshotInfo__isset, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, _SnapshotInfo__isset, name)
|
|
__repr__ = _swig_repr
|
|
def __init__(self):
|
|
this = _hedvigpyc.new__SnapshotInfo__isset()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_setmethods__["snapshot"] = _hedvigpyc._SnapshotInfo__isset_snapshot_set
|
|
__swig_getmethods__["snapshot"] = _hedvigpyc._SnapshotInfo__isset_snapshot_get
|
|
if _newclass:snapshot = _swig_property(_hedvigpyc._SnapshotInfo__isset_snapshot_get, _hedvigpyc._SnapshotInfo__isset_snapshot_set)
|
|
__swig_setmethods__["vDiskInfo"] = _hedvigpyc._SnapshotInfo__isset_vDiskInfo_set
|
|
__swig_getmethods__["vDiskInfo"] = _hedvigpyc._SnapshotInfo__isset_vDiskInfo_get
|
|
if _newclass:vDiskInfo = _swig_property(_hedvigpyc._SnapshotInfo__isset_vDiskInfo_get, _hedvigpyc._SnapshotInfo__isset_vDiskInfo_set)
|
|
__swig_setmethods__["details"] = _hedvigpyc._SnapshotInfo__isset_details_set
|
|
__swig_getmethods__["details"] = _hedvigpyc._SnapshotInfo__isset_details_get
|
|
if _newclass:details = _swig_property(_hedvigpyc._SnapshotInfo__isset_details_get, _hedvigpyc._SnapshotInfo__isset_details_set)
|
|
__swig_destroy__ = _hedvigpyc.delete__SnapshotInfo__isset
|
|
__del__ = lambda self : None;
|
|
_SnapshotInfo__isset_swigregister = _hedvigpyc._SnapshotInfo__isset_swigregister
|
|
_SnapshotInfo__isset_swigregister(_SnapshotInfo__isset)
|
|
|
|
class SnapshotInfo(_object):
|
|
__swig_setmethods__ = {}
|
|
__setattr__ = lambda self, name, value: _swig_setattr(self, SnapshotInfo, name, value)
|
|
__swig_getmethods__ = {}
|
|
__getattr__ = lambda self, name: _swig_getattr(self, SnapshotInfo, name)
|
|
__repr__ = _swig_repr
|
|
__swig_setmethods__["snapshot"] = _hedvigpyc.SnapshotInfo_snapshot_set
|
|
__swig_getmethods__["snapshot"] = _hedvigpyc.SnapshotInfo_snapshot_get
|
|
if _newclass:snapshot = _swig_property(_hedvigpyc.SnapshotInfo_snapshot_get, _hedvigpyc.SnapshotInfo_snapshot_set)
|
|
__swig_setmethods__["vDiskInfo"] = _hedvigpyc.SnapshotInfo_vDiskInfo_set
|
|
__swig_getmethods__["vDiskInfo"] = _hedvigpyc.SnapshotInfo_vDiskInfo_get
|
|
if _newclass:vDiskInfo = _swig_property(_hedvigpyc.SnapshotInfo_vDiskInfo_get, _hedvigpyc.SnapshotInfo_vDiskInfo_set)
|
|
__swig_setmethods__["details"] = _hedvigpyc.SnapshotInfo_details_set
|
|
__swig_getmethods__["details"] = _hedvigpyc.SnapshotInfo_details_get
|
|
if _newclass:details = _swig_property(_hedvigpyc.SnapshotInfo_details_get, _hedvigpyc.SnapshotInfo_details_set)
|
|
__swig_setmethods__["__isset"] = _hedvigpyc.SnapshotInfo___isset_set
|
|
__swig_getmethods__["__isset"] = _hedvigpyc.SnapshotInfo___isset_get
|
|
if _newclass:__isset = _swig_property(_hedvigpyc.SnapshotInfo___isset_get, _hedvigpyc.SnapshotInfo___isset_set)
|
|
def __init__(self):
|
|
this = _hedvigpyc.new_SnapshotInfo()
|
|
try: self.this.append(this)
|
|
except: self.this = this
|
|
__swig_destroy__ = _hedvigpyc.delete_SnapshotInfo
|
|
__del__ = lambda self : None;
|
|
SnapshotInfo_swigregister = _hedvigpyc.SnapshotInfo_swigregister
|
|
SnapshotInfo_swigregister(SnapshotInfo)
|
|
|
|
|
|
def hedvigpycInit(*args):
|
|
return _hedvigpyc.hedvigpycInit(*args)
|
|
hedvigpycInit = _hedvigpyc.hedvigpycInit
|
|
|
|
def hedvigpycShutdown():
|
|
return _hedvigpyc.hedvigpycShutdown()
|
|
hedvigpycShutdown = _hedvigpyc.hedvigpycShutdown
|
|
|
|
|