signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_mtu(self):
|
return self.__mtu<EOL>
|
Getter method for mtu, mapped from YANG variable /interface/homerun/mtu (mtu-type)
YANG Description: The size of the largest packet which can be sent/
received on the interface, specified in bytes.
For interfaces that are used for transmitting network
datagrams, this is the size of the largest network
datagram that can be sent on the interface.
|
f336550:c0:m33
|
def _set_mtu(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for mtu, mapped from YANG variable /interface/homerun/mtu (mtu-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mtu() directly.
YANG Description: The size of the largest packet which can be sent/
received on the interface, specified in bytes.
For interfaces that are used for transmitting network
datagrams, this is the size of the largest network
datagram that can be sent on the interface.
|
f336550:c0:m34
|
def _get_switchport_basic(self):
|
return self.__switchport_basic<EOL>
|
Getter method for switchport_basic, mapped from YANG variable /interface/homerun/switchport_basic (container)
|
f336550:c0:m36
|
def _set_switchport_basic(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=switchport_basic.switchport_basic, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__switchport_basic = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for switchport_basic, mapped from YANG variable /interface/homerun/switchport_basic (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_switchport_basic is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_switchport_basic() directly.
|
f336550:c0:m37
|
def _get_switchport(self):
|
return self.__switchport<EOL>
|
Getter method for switchport, mapped from YANG variable /interface/homerun/switchport (container)
YANG Description: The L2 switching characteristics of an interface.
|
f336550:c0:m39
|
def _set_switchport(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=switchport.switchport, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__switchport = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for switchport, mapped from YANG variable /interface/homerun/switchport (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_switchport is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_switchport() directly.
YANG Description: The L2 switching characteristics of an interface.
|
f336550:c0:m40
|
def _get_lacp(self):
|
return self.__lacp<EOL>
|
Getter method for lacp, mapped from YANG variable /interface/homerun/lacp (container)
|
f336550:c0:m42
|
def _set_lacp(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=lacp.lacp, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lacp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for lacp, mapped from YANG variable /interface/homerun/lacp (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_lacp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lacp() directly.
|
f336550:c0:m43
|
def _get_lldp(self):
|
return self.__lldp<EOL>
|
Getter method for lldp, mapped from YANG variable /interface/homerun/lldp (container)
|
f336550:c0:m45
|
def _set_lldp(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=lldp.lldp, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__lldp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for lldp, mapped from YANG variable /interface/homerun/lldp (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_lldp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lldp() directly.
|
f336550:c0:m46
|
def _get_sflow(self):
|
return self.__sflow<EOL>
|
Getter method for sflow, mapped from YANG variable /interface/homerun/sflow (container)
|
f336550:c0:m48
|
def _set_sflow(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=sflow.sflow, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__sflow = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for sflow, mapped from YANG variable /interface/homerun/sflow (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_sflow is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sflow() directly.
|
f336550:c0:m49
|
def _get_udld(self):
|
return self.__udld<EOL>
|
Getter method for udld, mapped from YANG variable /interface/homerun/udld (container)
YANG Description: Interface specific UDLD configurations.
|
f336550:c0:m51
|
def _set_udld(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=udld.udld, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__udld = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for udld, mapped from YANG variable /interface/homerun/udld (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_udld is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_udld() directly.
YANG Description: Interface specific UDLD configurations.
|
f336550:c0:m52
|
def _get_trunk_vlan_id(self):
|
return self.__trunk_vlan_id<EOL>
|
Getter method for trunk_vlan_id, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/remove/trunk_vlan_id (non-dot1q-vlan-type)
|
f336551:c0:m3
|
def _set_trunk_vlan_id(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk_vlan_id, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/remove/trunk_vlan_id (non-dot1q-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk_vlan_id() directly.
|
f336551:c0:m4
|
def _get_trunk_ctag_range(self):
|
return self.__trunk_ctag_range<EOL>
|
Getter method for trunk_ctag_range, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/remove/trunk_ctag_range (ui32-ctag-range)
|
f336551:c0:m6
|
def _set_trunk_ctag_range(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk_ctag_range = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk_ctag_range, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/remove/trunk_ctag_range (ui32-ctag-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_ctag_range is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk_ctag_range() directly.
|
f336551:c0:m7
|
def _get_trunk_vlan_id(self):
|
return self.__trunk_vlan_id<EOL>
|
Getter method for trunk_vlan_id, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/add/trunk_vlan_id (non-dot1q-vlan-type)
|
f336552:c0:m3
|
def _set_trunk_vlan_id(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk_vlan_id, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/add/trunk_vlan_id (non-dot1q-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk_vlan_id() directly.
|
f336552:c0:m4
|
def _get_trunk_ctag_range(self):
|
return self.__trunk_ctag_range<EOL>
|
Getter method for trunk_ctag_range, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/add/trunk_ctag_range (ui32-ctag-range)
|
f336552:c0:m6
|
def _set_trunk_ctag_range(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk_ctag_range = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk_ctag_range, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/add/trunk_ctag_range (ui32-ctag-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_ctag_range is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk_ctag_range() directly.
|
f336552:c0:m7
|
def _get_add_(self):
|
return self.__add_<EOL>
|
Getter method for add_, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/add (list)
|
f336553:c0:m3
|
def _set_add_(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",add_.add_, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__add_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for add_, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/add (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_add_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_add_() directly.
|
f336553:c0:m4
|
def _get_remove_(self):
|
return self.__remove_<EOL>
|
Getter method for remove_, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/remove (list)
|
f336553:c0:m6
|
def _set_remove_(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",remove_.remove_, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__remove_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for remove_, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan/remove (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_remove_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remove_() directly.
|
f336553:c0:m7
|
def _get_vlan(self):
|
return self.__vlan<EOL>
|
Getter method for vlan, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan (container)
|
f336554:c0:m3
|
def _set_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=vlan.vlan, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vlan, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed/vlan (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly.
|
f336554:c0:m4
|
def _get_allowed(self):
|
return self.__allowed<EOL>
|
Getter method for allowed, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed (container)
YANG Description: Set the VLANs that will Xmit/Rx through the Layer2
interface
|
f336555:c0:m3
|
def _set_allowed(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=allowed.allowed, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__allowed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for allowed, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification/allowed (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_allowed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_allowed() directly.
YANG Description: Set the VLANs that will Xmit/Rx through the Layer2
interface
|
f336555:c0:m4
|
def _get_default_transparent_vlan(self):
|
return self.__default_transparent_vlan<EOL>
|
Getter method for default_transparent_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/default_vlan_config/default_transparent_vlan (non-dot1q-vlan-type)
|
f336556:c0:m3
|
def _set_default_transparent_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__default_transparent_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for default_transparent_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/default_vlan_config/default_transparent_vlan (non-dot1q-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_transparent_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_transparent_vlan() directly.
|
f336556:c0:m4
|
def _get_all(self):
|
return self.__all<EOL>
|
Getter method for all, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan/all (empty)
YANG Description: This is to specify all dot1q vlans or not.
Presence of this leaf indicates all
dot1q vlans are allowed.
|
f336557:c0:m3
|
def _set_all(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT:all>", rest_name="<STR_LIT:all>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__all = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for all, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan/all (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_all is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_all() directly.
YANG Description: This is to specify all dot1q vlans or not.
Presence of this leaf indicates all
dot1q vlans are allowed.
|
f336557:c0:m4
|
def _get_none(self):
|
return self.__none<EOL>
|
Getter method for none, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan/none (empty)
YANG Description: This is to specify 'no dot1q vlans' or not.
Presence of this leaf indicates no dot1q
vlans are allowed.
|
f336557:c0:m6
|
def _set_none(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT:none>", rest_name="<STR_LIT:none>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__none = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for none, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan/none (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_none is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_none() directly.
YANG Description: This is to specify 'no dot1q vlans' or not.
Presence of this leaf indicates no dot1q
vlans are allowed.
|
f336557:c0:m7
|
def _get_add_(self):
|
return self.__add_<EOL>
|
Getter method for add_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan/add (ui32-vlan-20k-range)
YANG Description: This specifies list of vlans to
be added.
|
f336557:c0:m9
|
def _set_add_(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__add_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for add_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan/add (ui32-vlan-20k-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_add_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_add_() directly.
YANG Description: This specifies list of vlans to
be added.
|
f336557:c0:m10
|
def _get_except_(self):
|
return self.__except_<EOL>
|
Getter method for except_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan/except (ui32-1k-vlan-range)
YANG Description: This specifies exception list of
vlans.
|
f336557:c0:m12
|
def _set_except_(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__except_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for except_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan/except (ui32-1k-vlan-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_except_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_except_() directly.
YANG Description: This specifies exception list of
vlans.
|
f336557:c0:m13
|
def _get_remove_(self):
|
return self.__remove_<EOL>
|
Getter method for remove_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan/remove (ui32-1k-vlan-range)
YANG Description: This specifies the list of vlans
to be removed.
|
f336557:c0:m15
|
def _set_remove_(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__remove_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for remove_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan/remove (ui32-1k-vlan-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_remove_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remove_() directly.
YANG Description: This specifies the list of vlans
to be removed.
|
f336557:c0:m16
|
def _get_add_rspan_trunk_vlan(self):
|
return self.__add_rspan_trunk_vlan<EOL>
|
Getter method for add_rspan_trunk_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/rspan_vlan/add_rspan_trunk_vlan (ui32-1k-vlan-range)
YANG Description: Specify rspan-vlan id
|
f336558:c0:m3
|
def _set_add_rspan_trunk_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__add_rspan_trunk_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for add_rspan_trunk_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/rspan_vlan/add_rspan_trunk_vlan (ui32-1k-vlan-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_add_rspan_trunk_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_add_rspan_trunk_vlan() directly.
YANG Description: Specify rspan-vlan id
|
f336558:c0:m4
|
def _get_remove_rspan_trunk_vlan(self):
|
return self.__remove_rspan_trunk_vlan<EOL>
|
Getter method for remove_rspan_trunk_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/rspan_vlan/remove_rspan_trunk_vlan (ui32-1k-vlan-range)
YANG Description: This specifies the list of rspan vlans to be removed.
|
f336558:c0:m6
|
def _set_remove_rspan_trunk_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__remove_rspan_trunk_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for remove_rspan_trunk_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/rspan_vlan/remove_rspan_trunk_vlan (ui32-1k-vlan-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_remove_rspan_trunk_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remove_rspan_trunk_vlan() directly.
YANG Description: This specifies the list of rspan vlans to be removed.
|
f336558:c0:m7
|
def _get_trunk_vlan_id(self):
|
return self.__trunk_vlan_id<EOL>
|
Getter method for trunk_vlan_id, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/remove/trunk_vlan_id (non-dot1q-vlan-type)
|
f336559:c0:m3
|
def _set_trunk_vlan_id(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk_vlan_id, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/remove/trunk_vlan_id (non-dot1q-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk_vlan_id() directly.
|
f336559:c0:m4
|
def _get_trunk_ctag_id(self):
|
return self.__trunk_ctag_id<EOL>
|
Getter method for trunk_ctag_id, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/remove/trunk_ctag_id (dot1q-vlan-type)
|
f336559:c0:m6
|
def _set_trunk_ctag_id(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk_ctag_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk_ctag_id, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/remove/trunk_ctag_id (dot1q-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_ctag_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk_ctag_id() directly.
|
f336559:c0:m7
|
def _get_trunk_vlan_id(self):
|
return self.__trunk_vlan_id<EOL>
|
Getter method for trunk_vlan_id, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/add/trunk_vlan_id (non-dot1q-vlan-type)
|
f336560:c0:m3
|
def _set_trunk_vlan_id(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk_vlan_id, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/add/trunk_vlan_id (non-dot1q-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk_vlan_id() directly.
|
f336560:c0:m4
|
def _get_trunk_ctag_id(self):
|
return self.__trunk_ctag_id<EOL>
|
Getter method for trunk_ctag_id, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/add/trunk_ctag_id (dot1q-vlan-type)
|
f336560:c0:m6
|
def _set_trunk_ctag_id(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk_ctag_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk_ctag_id, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/add/trunk_ctag_id (dot1q-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_ctag_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk_ctag_id() directly.
|
f336560:c0:m7
|
def _get_add_(self):
|
return self.__add_<EOL>
|
Getter method for add_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/add (list)
|
f336561:c0:m3
|
def _set_add_(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",add_.add_, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__add_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for add_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/add (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_add_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_add_() directly.
|
f336561:c0:m4
|
def _get_remove_(self):
|
return self.__remove_<EOL>
|
Getter method for remove_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/remove (list)
|
f336561:c0:m6
|
def _set_remove_(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",remove_.remove_, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__remove_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for remove_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan/remove (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_remove_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remove_() directly.
|
f336561:c0:m7
|
def _get_rspan_vlan(self):
|
return self.__rspan_vlan<EOL>
|
Getter method for rspan_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan (container)
|
f336562:c0:m3
|
def _set_rspan_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=rspan_vlan.rspan_vlan, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rspan_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for rspan_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification/rspan_vlan (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_rspan_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rspan_vlan() directly.
|
f336562:c0:m4
|
def _get_vlan(self):
|
return self.__vlan<EOL>
|
Getter method for vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan (container)
|
f336563:c0:m3
|
def _set_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=vlan.vlan, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlan (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly.
|
f336563:c0:m4
|
def _get_vlanoper(self):
|
return self.__vlanoper<EOL>
|
Getter method for vlanoper, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlanoper (container)
YANG Description: DEPRECATED
NOS2.1.0 style data model for allowed vlans.
Do not use in edit-config.
|
f336563:c0:m6
|
def _set_vlanoper(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=vlanoper.vlanoper, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlanoper = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vlanoper, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlanoper (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlanoper is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlanoper() directly.
YANG Description: DEPRECATED
NOS2.1.0 style data model for allowed vlans.
Do not use in edit-config.
|
f336563:c0:m7
|
def _get_rspan_vlan(self):
|
return self.__rspan_vlan<EOL>
|
Getter method for rspan_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/rspan_vlan (container)
YANG Description: configure a rspan-vlan
|
f336563:c0:m9
|
def _set_rspan_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=rspan_vlan.rspan_vlan, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rspan_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for rspan_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/rspan_vlan (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_rspan_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rspan_vlan() directly.
YANG Description: configure a rspan-vlan
|
f336563:c0:m10
|
def _get_trunk_rspan_vlan_classification(self):
|
return self.__trunk_rspan_vlan_classification<EOL>
|
Getter method for trunk_rspan_vlan_classification, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification (container)
|
f336563:c0:m12
|
def _set_trunk_rspan_vlan_classification(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=trunk_rspan_vlan_classification.trunk_rspan_vlan_classification, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk_rspan_vlan_classification = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk_rspan_vlan_classification, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/trunk_rspan_vlan_classification (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_rspan_vlan_classification is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk_rspan_vlan_classification() directly.
|
f336563:c0:m13
|
def _get_add_(self):
|
return self.__add_<EOL>
|
Getter method for add_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlanoper/vlan/add (ui32-vlan-range)
|
f336564:c0:m3
|
def _set_add_(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__add_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for add_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlanoper/vlan/add (ui32-vlan-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_add_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_add_() directly.
|
f336564:c0:m4
|
def _get_remove_(self):
|
return self.__remove_<EOL>
|
Getter method for remove_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlanoper/vlan/remove (ui32-vlan-range)
|
f336564:c0:m6
|
def _set_remove_(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__remove_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for remove_, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlanoper/vlan/remove (ui32-vlan-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_remove_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remove_() directly.
|
f336564:c0:m7
|
def _get_vlan(self):
|
return self.__vlan<EOL>
|
Getter method for vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlanoper/vlan (container)
|
f336565:c0:m3
|
def _set_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=vlan.vlan, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vlan, mapped from YANG variable /interface/homerun/switchport/trunk/allowed/vlanoper/vlan (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly.
|
f336565:c0:m4
|
def _get_native_vlan_id_xtagged(self):
|
return self.__native_vlan_id_xtagged<EOL>
|
Getter method for native_vlan_id_xtagged, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_xtagged_config/native_vlan_id_xtagged (vlan-type)
YANG Description: The native vlan for an interface.
|
f336566:c0:m3
|
def _set_native_vlan_id_xtagged(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__native_vlan_id_xtagged = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for native_vlan_id_xtagged, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_xtagged_config/native_vlan_id_xtagged (vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_vlan_id_xtagged is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_vlan_id_xtagged() directly.
YANG Description: The native vlan for an interface.
|
f336566:c0:m4
|
def _get_native_vlan_ctag_id_xtagged(self):
|
return self.__native_vlan_ctag_id_xtagged<EOL>
|
Getter method for native_vlan_ctag_id_xtagged, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_xtagged_config/native_vlan_ctag_id_xtagged (dot1q-vlan-type)
YANG Description: Associate a Ctag.
|
f336566:c0:m6
|
def _set_native_vlan_ctag_id_xtagged(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__native_vlan_ctag_id_xtagged = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for native_vlan_ctag_id_xtagged, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_xtagged_config/native_vlan_ctag_id_xtagged (dot1q-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_vlan_ctag_id_xtagged is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_vlan_ctag_id_xtagged() directly.
YANG Description: Associate a Ctag.
|
f336566:c0:m7
|
def _get_native_vlan_egress_type_xtagged(self):
|
return self.__native_vlan_egress_type_xtagged<EOL>
|
Getter method for native_vlan_egress_type_xtagged, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_xtagged_config/native_vlan_egress_type_xtagged (enumeration)
|
f336566:c0:m9
|
def _set_native_vlan_egress_type_xtagged(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__native_vlan_egress_type_xtagged = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for native_vlan_egress_type_xtagged, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_xtagged_config/native_vlan_egress_type_xtagged (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_vlan_egress_type_xtagged is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_vlan_egress_type_xtagged() directly.
|
f336566:c0:m10
|
def _get_allowed(self):
|
return self.__allowed<EOL>
|
Getter method for allowed, mapped from YANG variable /interface/homerun/switchport/trunk/allowed (container)
YANG Description: Set the VLANs that will Xmit/Rx through the Layer2
interface
|
f336567:c0:m3
|
def _set_allowed(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=allowed.allowed, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__allowed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for allowed, mapped from YANG variable /interface/homerun/switchport/trunk/allowed (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_allowed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_allowed() directly.
YANG Description: Set the VLANs that will Xmit/Rx through the Layer2
interface
|
f336567:c0:m4
|
def _get_trunk_vlan_classification(self):
|
return self.__trunk_vlan_classification<EOL>
|
Getter method for trunk_vlan_classification, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification (container)
|
f336567:c0:m6
|
def _set_trunk_vlan_classification(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=trunk_vlan_classification.trunk_vlan_classification, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk_vlan_classification = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk_vlan_classification, mapped from YANG variable /interface/homerun/switchport/trunk/trunk_vlan_classification (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_vlan_classification is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk_vlan_classification() directly.
|
f336567:c0:m7
|
def _get_default_vlan_config(self):
|
return self.__default_vlan_config<EOL>
|
Getter method for default_vlan_config, mapped from YANG variable /interface/homerun/switchport/trunk/default_vlan_config (container)
|
f336567:c0:m9
|
def _set_default_vlan_config(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=default_vlan_config.default_vlan_config, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__default_vlan_config = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for default_vlan_config, mapped from YANG variable /interface/homerun/switchport/trunk/default_vlan_config (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_vlan_config is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_vlan_config() directly.
|
f336567:c0:m10
|
def _get_tag(self):
|
return self.__tag<EOL>
|
Getter method for tag, mapped from YANG variable /interface/homerun/switchport/trunk/tag (container)
YANG Description: This specifies vlan tagging characteristics for a
trunk port.
|
f336567:c0:m12
|
def _set_tag(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=tag.tag, is_container='<STR_LIT>', presence=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tag = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for tag, mapped from YANG variable /interface/homerun/switchport/trunk/tag (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_tag is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tag() directly.
YANG Description: This specifies vlan tagging characteristics for a
trunk port.
|
f336567:c0:m13
|
def _get_native_vlan_classification(self):
|
return self.__native_vlan_classification<EOL>
|
Getter method for native_vlan_classification, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_classification (container)
|
f336567:c0:m15
|
def _set_native_vlan_classification(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=native_vlan_classification.native_vlan_classification, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__native_vlan_classification = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for native_vlan_classification, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_classification (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_vlan_classification is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_vlan_classification() directly.
|
f336567:c0:m16
|
def _get_native_vlan_xtagged_config(self):
|
return self.__native_vlan_xtagged_config<EOL>
|
Getter method for native_vlan_xtagged_config, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_xtagged_config (container)
|
f336567:c0:m18
|
def _set_native_vlan_xtagged_config(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=native_vlan_xtagged_config.native_vlan_xtagged_config, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__native_vlan_xtagged_config = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for native_vlan_xtagged_config, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_xtagged_config (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_vlan_xtagged_config is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_vlan_xtagged_config() directly.
|
f336567:c0:m19
|
def _get_native_vlan_untagged_config(self):
|
return self.__native_vlan_untagged_config<EOL>
|
Getter method for native_vlan_untagged_config, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_untagged_config (container)
|
f336567:c0:m21
|
def _set_native_vlan_untagged_config(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=native_vlan_untagged_config.native_vlan_untagged_config, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__native_vlan_untagged_config = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for native_vlan_untagged_config, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_untagged_config (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_vlan_untagged_config is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_vlan_untagged_config() directly.
|
f336567:c0:m22
|
def _get_native_vlan_id_untagged(self):
|
return self.__native_vlan_id_untagged<EOL>
|
Getter method for native_vlan_id_untagged, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_untagged_config/native_vlan_id_untagged (vlan-type)
YANG Description: The native vlan for an interface.
|
f336568:c0:m3
|
def _set_native_vlan_id_untagged(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__native_vlan_id_untagged = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for native_vlan_id_untagged, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_untagged_config/native_vlan_id_untagged (vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_vlan_id_untagged is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_vlan_id_untagged() directly.
YANG Description: The native vlan for an interface.
|
f336568:c0:m4
|
def _get_native_vlan_id(self):
|
return self.__native_vlan_id<EOL>
|
Getter method for native_vlan_id, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_classification/native_vlan_id (native-vlan-type)
YANG Description: The native vlan for an interface.
|
f336569:c0:m3
|
def _set_native_vlan_id(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__native_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for native_vlan_id, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_classification/native_vlan_id (native-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_vlan_id() directly.
YANG Description: The native vlan for an interface.
|
f336569:c0:m4
|
def _get_native_vlan_ctag_id(self):
|
return self.__native_vlan_ctag_id<EOL>
|
Getter method for native_vlan_ctag_id, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_classification/native_vlan_ctag_id (dot1q-vlan-type)
YANG Description: Associate a Ctag.
|
f336569:c0:m6
|
def _set_native_vlan_ctag_id(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__native_vlan_ctag_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for native_vlan_ctag_id, mapped from YANG variable /interface/homerun/switchport/trunk/native_vlan_classification/native_vlan_ctag_id (dot1q-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_vlan_ctag_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_vlan_ctag_id() directly.
YANG Description: Associate a Ctag.
|
f336569:c0:m7
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.