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





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

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

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

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

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



def MACAddress_set(*args):
  """MACAddress_set(ofdpaMacAddr_t address, char * a) -> char *"""
  return _OFDPA_python.MACAddress_set(*args)

def MACAddress_get(*args):
  """MACAddress_get(ofdpaMacAddr_t address) -> char *"""
  return _OFDPA_python.MACAddress_get(*args)

def in6Address_set(*args):
  """in6Address_set(in6_addr address, char * a) -> char *"""
  return _OFDPA_python.in6Address_set(*args)

def in6Address_get(*args):
  """in6Address_get(in6_addr address) -> char *"""
  return _OFDPA_python.in6Address_get(*args)

def BuffDesc_pstart_setbytes(*args):
  """BuffDesc_pstart_setbytes(ofdpa_buffdesc buffdesc, char const * value) -> int"""
  return _OFDPA_python.BuffDesc_pstart_setbytes(*args)

def BuffDesc_getbyte(*args):
  """BuffDesc_getbyte(ofdpa_buffdesc buffdesc, int offset) -> int"""
  return _OFDPA_python.BuffDesc_getbyte(*args)

def BuffDesc_setbyte(*args):
  """BuffDesc_setbyte(ofdpa_buffdesc buffdesc, int offset, char const data) -> int"""
  return _OFDPA_python.BuffDesc_setbyte(*args)
class in6_addr(_object):
    """Proxy of C in6_addr struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, in6_addr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, in6_addr, name)
    __repr__ = _swig_repr
    __swig_setmethods__["s6_addr"] = _OFDPA_python.in6_addr_s6_addr_set
    __swig_getmethods__["s6_addr"] = _OFDPA_python.in6_addr_s6_addr_get
    if _newclass:s6_addr = _swig_property(_OFDPA_python.in6_addr_s6_addr_get, _OFDPA_python.in6_addr_s6_addr_set)
    def __init__(self): 
        """__init__(in6_addr self) -> in6_addr"""
        this = _OFDPA_python.new_in6_addr()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_in6_addr
    __del__ = lambda self : None;
in6_addr_swigregister = _OFDPA_python.in6_addr_swigregister
in6_addr_swigregister(in6_addr)

class timeval(_object):
    """Proxy of C timeval struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, timeval, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, timeval, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tv_sec"] = _OFDPA_python.timeval_tv_sec_set
    __swig_getmethods__["tv_sec"] = _OFDPA_python.timeval_tv_sec_get
    if _newclass:tv_sec = _swig_property(_OFDPA_python.timeval_tv_sec_get, _OFDPA_python.timeval_tv_sec_set)
    __swig_setmethods__["tv_usec"] = _OFDPA_python.timeval_tv_usec_set
    __swig_getmethods__["tv_usec"] = _OFDPA_python.timeval_tv_usec_get
    if _newclass:tv_usec = _swig_property(_OFDPA_python.timeval_tv_usec_get, _OFDPA_python.timeval_tv_usec_set)
    def __init__(self): 
        """__init__(timeval self) -> timeval"""
        this = _OFDPA_python.new_timeval()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_timeval
    __del__ = lambda self : None;
timeval_swigregister = _OFDPA_python.timeval_swigregister
timeval_swigregister(timeval)


def new_uint8_tp():
  """new_uint8_tp() -> uint8_t *"""
  return _OFDPA_python.new_uint8_tp()

def copy_uint8_tp(*args):
  """copy_uint8_tp(uint8_t value) -> uint8_t *"""
  return _OFDPA_python.copy_uint8_tp(*args)

def delete_uint8_tp(*args):
  """delete_uint8_tp(uint8_t * obj)"""
  return _OFDPA_python.delete_uint8_tp(*args)

def uint8_tp_assign(*args):
  """uint8_tp_assign(uint8_t * obj, uint8_t value)"""
  return _OFDPA_python.uint8_tp_assign(*args)

def uint8_tp_value(*args):
  """uint8_tp_value(uint8_t * obj) -> uint8_t"""
  return _OFDPA_python.uint8_tp_value(*args)

def new_uint16_tp():
  """new_uint16_tp() -> uint16_t *"""
  return _OFDPA_python.new_uint16_tp()

def copy_uint16_tp(*args):
  """copy_uint16_tp(uint16_t value) -> uint16_t *"""
  return _OFDPA_python.copy_uint16_tp(*args)

def delete_uint16_tp(*args):
  """delete_uint16_tp(uint16_t * obj)"""
  return _OFDPA_python.delete_uint16_tp(*args)

def uint16_tp_assign(*args):
  """uint16_tp_assign(uint16_t * obj, uint16_t value)"""
  return _OFDPA_python.uint16_tp_assign(*args)

def uint16_tp_value(*args):
  """uint16_tp_value(uint16_t * obj) -> uint16_t"""
  return _OFDPA_python.uint16_tp_value(*args)

def new_uint32_tp():
  """new_uint32_tp() -> uint32_t *"""
  return _OFDPA_python.new_uint32_tp()

def copy_uint32_tp(*args):
  """copy_uint32_tp(uint32_t value) -> uint32_t *"""
  return _OFDPA_python.copy_uint32_tp(*args)

def delete_uint32_tp(*args):
  """delete_uint32_tp(uint32_t * obj)"""
  return _OFDPA_python.delete_uint32_tp(*args)

def uint32_tp_assign(*args):
  """uint32_tp_assign(uint32_t * obj, uint32_t value)"""
  return _OFDPA_python.uint32_tp_assign(*args)

def uint32_tp_value(*args):
  """uint32_tp_value(uint32_t * obj) -> uint32_t"""
  return _OFDPA_python.uint32_tp_value(*args)

def new_uint64_tp():
  """new_uint64_tp() -> uint64_t *"""
  return _OFDPA_python.new_uint64_tp()

def copy_uint64_tp(*args):
  """copy_uint64_tp(uint64_t value) -> uint64_t *"""
  return _OFDPA_python.copy_uint64_tp(*args)

def delete_uint64_tp(*args):
  """delete_uint64_tp(uint64_t * obj)"""
  return _OFDPA_python.delete_uint64_tp(*args)

def uint64_tp_assign(*args):
  """uint64_tp_assign(uint64_t * obj, uint64_t value)"""
  return _OFDPA_python.uint64_tp_assign(*args)

def uint64_tp_value(*args):
  """uint64_tp_value(uint64_t * obj) -> uint64_t"""
  return _OFDPA_python.uint64_tp_value(*args)

def ofdpaClientInitialize(*args):
  """ofdpaClientInitialize(char * clientName) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaClientInitialize(*args)

def ofdpaFeatureSupported(*args):
  """ofdpaFeatureSupported(OFDPA_FEATURE_t feature) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFeatureSupported(*args)

def ofdpaCltLogPrintf(*args):
  """ofdpaCltLogPrintf(int priority, char * fmt) -> int"""
  return _OFDPA_python.ofdpaCltLogPrintf(*args)

def ofdpaCltLogBuf(*args):
  """ofdpaCltLogBuf(int priority, ofdpa_buffdesc message) -> int"""
  return _OFDPA_python.ofdpaCltLogBuf(*args)

def ofdpaCltDebugPrintf(*args):
  """
    ofdpaCltDebugPrintf(char const * functionName, ofdpaComponentIds_t component, ofdpaDebugLevels_t verbosity, 
        char const * format) -> int
    """
  return _OFDPA_python.ofdpaCltDebugPrintf(*args)

def ofdpaCltDebugBuf(*args):
  """
    ofdpaCltDebugBuf(ofdpa_buffdesc functionName, ofdpaComponentIds_t component, ofdpaDebugLevels_t verbosity, 
        ofdpa_buffdesc message) -> int
    """
  return _OFDPA_python.ofdpaCltDebugBuf(*args)

def ofdpaFlowTableSupported(*args):
  """ofdpaFlowTableSupported(OFDPA_FLOW_TABLE_ID_t tableId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowTableSupported(*args)

def ofdpaFlowEntryInit(*args):
  """ofdpaFlowEntryInit(OFDPA_FLOW_TABLE_ID_t tableId, ofdpaFlowEntry_t flow) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowEntryInit(*args)

def ofdpaFlowAdd(*args):
  """ofdpaFlowAdd(ofdpaFlowEntry_t flow) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowAdd(*args)

def ofdpaFlowModify(*args):
  """ofdpaFlowModify(ofdpaFlowEntry_t flow) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowModify(*args)

def ofdpaFlowDelete(*args):
  """ofdpaFlowDelete(ofdpaFlowEntry_t flow) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowDelete(*args)

def ofdpaFlowNextGet(*args):
  """ofdpaFlowNextGet(ofdpaFlowEntry_t flow, ofdpaFlowEntry_t nextFlow) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowNextGet(*args)

def ofdpaFlowStatsGet(*args):
  """ofdpaFlowStatsGet(ofdpaFlowEntry_t flow, ofdpaFlowEntryStats_t flowStats) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowStatsGet(*args)

def ofdpaFlowByCookieGet(*args):
  """ofdpaFlowByCookieGet(uint64_t cookie, ofdpaFlowEntry_t flow, ofdpaFlowEntryStats_t flowStats) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowByCookieGet(*args)

def ofdpaFlowByCookieDelete(*args):
  """ofdpaFlowByCookieDelete(uint64_t cookie) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowByCookieDelete(*args)

def ofdpaGroupTypeGet(*args):
  """ofdpaGroupTypeGet(uint32_t groupId, uint32_t * type) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupTypeGet(*args)

def ofdpaGroupVlanGet(*args):
  """ofdpaGroupVlanGet(uint32_t groupId, uint32_t * vlanId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupVlanGet(*args)

def ofdpaGroupPortIdGet(*args):
  """ofdpaGroupPortIdGet(uint32_t groupId, uint32_t * portId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupPortIdGet(*args)

def ofdpaGroupIndexGet(*args):
  """ofdpaGroupIndexGet(uint32_t groupId, uint32_t * index) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupIndexGet(*args)

def ofdpaGroupTypeSet(*args):
  """ofdpaGroupTypeSet(uint32_t * groupId, uint32_t type) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupTypeSet(*args)

def ofdpaGroupVlanSet(*args):
  """ofdpaGroupVlanSet(uint32_t * groupId, uint32_t vlanId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupVlanSet(*args)

def ofdpaGroupOverlayTunnelIdGet(*args):
  """ofdpaGroupOverlayTunnelIdGet(uint32_t groupId, uint32_t * tunnelId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupOverlayTunnelIdGet(*args)

def ofdpaGroupOverlayTunnelIdSet(*args):
  """ofdpaGroupOverlayTunnelIdSet(uint32_t * groupId, uint32_t tunnelId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupOverlayTunnelIdSet(*args)

def ofdpaGroupOverlaySubTypeGet(*args):
  """ofdpaGroupOverlaySubTypeGet(uint32_t groupId, OFDPA_L2_OVERLAY_SUBTYPE_t * subType) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupOverlaySubTypeGet(*args)

def ofdpaGroupOverlaySubTypeSet(*args):
  """ofdpaGroupOverlaySubTypeSet(uint32_t * groupId, OFDPA_L2_OVERLAY_SUBTYPE_t subType) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupOverlaySubTypeSet(*args)

def ofdpaGroupOverlayIndexGet(*args):
  """ofdpaGroupOverlayIndexGet(uint32_t groupId, uint32_t * index) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupOverlayIndexGet(*args)

def ofdpaGroupOverlayIndexSet(*args):
  """ofdpaGroupOverlayIndexSet(uint32_t * groupId, uint32_t index) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupOverlayIndexSet(*args)

def ofdpaGroupMplsL2TunnelIdGet(*args):
  """ofdpaGroupMplsL2TunnelIdGet(uint32_t groupId, uint32_t * tunnelId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupMplsL2TunnelIdGet(*args)

def ofdpaGroupMplsL2TunnelIdSet(*args):
  """ofdpaGroupMplsL2TunnelIdSet(uint32_t * groupId, uint32_t tunnelId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupMplsL2TunnelIdSet(*args)

def ofdpaGroupMplsSubTypeGet(*args):
  """ofdpaGroupMplsSubTypeGet(uint32_t groupId, uint32_t * subType) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupMplsSubTypeGet(*args)

def ofdpaGroupMplsSubTypeSet(*args):
  """ofdpaGroupMplsSubTypeSet(uint32_t * groupId, uint32_t subType) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupMplsSubTypeSet(*args)

def ofdpaGroupPortIdSet(*args):
  """ofdpaGroupPortIdSet(uint32_t * groupId, uint32_t portId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupPortIdSet(*args)

def ofdpaGroupIndexSet(*args):
  """ofdpaGroupIndexSet(uint32_t * groupId, uint32_t index) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupIndexSet(*args)

def ofdpaGroupDecode(*args):
  """ofdpaGroupDecode(uint32_t groupId, char * outBuf, int bufSize) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupDecode(*args)

def ofdpaGroupBucketEntryDecode(*args):
  """ofdpaGroupBucketEntryDecode(ofdpaGroupBucketEntry_t bucketEntry, char * outBuf, int bufSize) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupBucketEntryDecode(*args)

def ofdpaQosColorDecode(*args):
  """ofdpaQosColorDecode(OFDPA_QOS_COLORS_t color) -> char const *"""
  return _OFDPA_python.ofdpaQosColorDecode(*args)

def ofdpaFlowTableNameGet(*args):
  """ofdpaFlowTableNameGet(OFDPA_FLOW_TABLE_ID_t tableId) -> char const *"""
  return _OFDPA_python.ofdpaFlowTableNameGet(*args)

def ofdpaFlowEntryDecode(*args):
  """ofdpaFlowEntryDecode(ofdpaFlowEntry_t flow, char * outBuf, int bufSize) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowEntryDecode(*args)

def ofdpaGroupAdd(*args):
  """ofdpaGroupAdd(ofdpaGroupEntry_t group) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupAdd(*args)

def ofdpaGroupDelete(*args):
  """ofdpaGroupDelete(uint32_t groupId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupDelete(*args)

def ofdpaGroupNextGet(*args):
  """ofdpaGroupNextGet(uint32_t groupId, ofdpaGroupEntry_t nextGroup) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupNextGet(*args)

def ofdpaGroupTypeNextGet(*args):
  """ofdpaGroupTypeNextGet(uint32_t groupId, OFDPA_GROUP_ENTRY_TYPE_t groupType, ofdpaGroupEntry_t nextGroup) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupTypeNextGet(*args)

def ofdpaGroupStatsGet(*args):
  """ofdpaGroupStatsGet(uint32_t groupId, ofdpaGroupEntryStats_t groupStats) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupStatsGet(*args)

def ofdpaGroupBucketEntryAdd(*args):
  """ofdpaGroupBucketEntryAdd(ofdpaGroupBucketEntry_t bucket) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupBucketEntryAdd(*args)

def ofdpaGroupBucketEntryDelete(*args):
  """ofdpaGroupBucketEntryDelete(uint32_t groupId, uint32_t bucketIndex) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupBucketEntryDelete(*args)

def ofdpaGroupBucketsDeleteAll(*args):
  """ofdpaGroupBucketsDeleteAll(uint32_t groupId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupBucketsDeleteAll(*args)

def ofdpaGroupBucketEntryGet(*args):
  """ofdpaGroupBucketEntryGet(uint32_t groupId, uint32_t bucketIndex, ofdpaGroupBucketEntry_t groupBucket) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupBucketEntryGet(*args)

def ofdpaGroupBucketEntryFirstGet(*args):
  """ofdpaGroupBucketEntryFirstGet(uint32_t groupId, ofdpaGroupBucketEntry_t firstGroupBucket) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupBucketEntryFirstGet(*args)

def ofdpaGroupBucketEntryNextGet(*args):
  """ofdpaGroupBucketEntryNextGet(uint32_t groupId, uint32_t bucketIndex, ofdpaGroupBucketEntry_t nextBucketEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupBucketEntryNextGet(*args)

def ofdpaGroupBucketEntryModify(*args):
  """ofdpaGroupBucketEntryModify(ofdpaGroupBucketEntry_t bucket) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupBucketEntryModify(*args)

def ofdpaGroupTableTotalEntryCountGet(*args):
  """ofdpaGroupTableTotalEntryCountGet(uint32_t * entryCount) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupTableTotalEntryCountGet(*args)

def ofdpaGroupTableInfoGet(*args):
  """ofdpaGroupTableInfoGet(uint32_t groupId, ofdpaGroupTableInfo_t info) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupTableInfoGet(*args)

def ofdpaPortTypeGet(*args):
  """ofdpaPortTypeGet(uint32_t portNum, uint32_t * type)"""
  return _OFDPA_python.ofdpaPortTypeGet(*args)

def ofdpaPortTypeSet(*args):
  """ofdpaPortTypeSet(uint32_t * portNum, uint32_t type)"""
  return _OFDPA_python.ofdpaPortTypeSet(*args)

def ofdpaPortIndexGet(*args):
  """ofdpaPortIndexGet(uint32_t portNum, uint32_t * index)"""
  return _OFDPA_python.ofdpaPortIndexGet(*args)

def ofdpaPortIndexSet(*args):
  """ofdpaPortIndexSet(uint32_t * portNum, uint32_t index)"""
  return _OFDPA_python.ofdpaPortIndexSet(*args)

def ofdpaPortNextGet(*args):
  """ofdpaPortNextGet(uint32_t portNum, uint32_t * nextPortNum) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortNextGet(*args)

def ofdpaPortMacGet(*args):
  """ofdpaPortMacGet(uint32_t portNum, ofdpaMacAddr_t mac) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortMacGet(*args)

def ofdpaPortNameGet(*args):
  """ofdpaPortNameGet(uint32_t portNum, ofdpa_buffdesc name) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortNameGet(*args)

def ofdpaPortStateGet(*args):
  """ofdpaPortStateGet(uint32_t portNum, uint32_t * state) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortStateGet(*args)

def ofdpaPortConfigSet(*args):
  """ofdpaPortConfigSet(uint32_t portNum, OFDPA_PORT_CONFIG_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortConfigSet(*args)

def ofdpaPortConfigGet(*args):
  """ofdpaPortConfigGet(uint32_t portNum, uint32_t * config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortConfigGet(*args)

def ofdpaPortMaxSpeedGet(*args):
  """ofdpaPortMaxSpeedGet(uint32_t portNum, uint32_t * maxSpeed) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortMaxSpeedGet(*args)

def ofdpaPortCurrSpeedGet(*args):
  """ofdpaPortCurrSpeedGet(uint32_t portNum, uint32_t * currSpeed) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortCurrSpeedGet(*args)

def ofdpaPortFeatureGet(*args):
  """ofdpaPortFeatureGet(uint32_t portNum, ofdpaPortFeature_t feature) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortFeatureGet(*args)

def ofdpaPortAdvertiseFeatureSet(*args):
  """ofdpaPortAdvertiseFeatureSet(uint32_t portNum, uint32_t advertise) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortAdvertiseFeatureSet(*args)

def ofdpaPortStatsClear(*args):
  """ofdpaPortStatsClear(uint32_t portNum) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortStatsClear(*args)

def ofdpaPortStatsGet(*args):
  """ofdpaPortStatsGet(uint32_t portNum, ofdpaPortStats_t stats) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortStatsGet(*args)

def ofdpaMplsL2PortTypeGet(*args):
  """ofdpaMplsL2PortTypeGet(uint32_t portNum, uint32_t * type)"""
  return _OFDPA_python.ofdpaMplsL2PortTypeGet(*args)

def ofdpaMplsL2PortTypeSet(*args):
  """ofdpaMplsL2PortTypeSet(uint32_t * portNum, uint32_t type)"""
  return _OFDPA_python.ofdpaMplsL2PortTypeSet(*args)

def ofdpaMplsL2PortIndexGet(*args):
  """ofdpaMplsL2PortIndexGet(uint32_t portNum, uint32_t * index)"""
  return _OFDPA_python.ofdpaMplsL2PortIndexGet(*args)

def ofdpaMplsL2PortIndexSet(*args):
  """ofdpaMplsL2PortIndexSet(uint32_t * portNum, uint32_t index)"""
  return _OFDPA_python.ofdpaMplsL2PortIndexSet(*args)

def ofdpaTunnelIdTypeGet(*args):
  """ofdpaTunnelIdTypeGet(uint32_t tunnelId, uint32_t * type)"""
  return _OFDPA_python.ofdpaTunnelIdTypeGet(*args)

def ofdpaTunnelIdIndexGet(*args):
  """ofdpaTunnelIdIndexGet(uint32_t tunnelId, uint32_t * index)"""
  return _OFDPA_python.ofdpaTunnelIdIndexGet(*args)

def ofdpaTunnelIdTypeSet(*args):
  """ofdpaTunnelIdTypeSet(uint32_t * tunnelId, uint32_t type)"""
  return _OFDPA_python.ofdpaTunnelIdTypeSet(*args)

def ofdpaTunnelIdIndexSet(*args):
  """ofdpaTunnelIdIndexSet(uint32_t * tunnelId, uint32_t index)"""
  return _OFDPA_python.ofdpaTunnelIdIndexSet(*args)

def ofdpaTunnelPortCreate(*args):
  """ofdpaTunnelPortCreate(uint32_t portNum, ofdpa_buffdesc name, ofdpaTunnelPortConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelPortCreate(*args)

def ofdpaTunnelPortDelete(*args):
  """ofdpaTunnelPortDelete(uint32_t portNum) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelPortDelete(*args)

def ofdpaTunnelPortGet(*args):
  """ofdpaTunnelPortGet(uint32_t portNum, ofdpaTunnelPortConfig_t config, ofdpaTunnelPortStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelPortGet(*args)

def ofdpaTunnelPortNextGet(*args):
  """ofdpaTunnelPortNextGet(uint32_t portNum, uint32_t * nextPortNum) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelPortNextGet(*args)

def ofdpaTunnelPortTenantAdd(*args):
  """ofdpaTunnelPortTenantAdd(uint32_t portNum, uint32_t tunnelId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelPortTenantAdd(*args)

def ofdpaTunnelPortTenantDelete(*args):
  """ofdpaTunnelPortTenantDelete(uint32_t portNum, uint32_t tunnelId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelPortTenantDelete(*args)

def ofdpaTunnelPortTenantGet(*args):
  """ofdpaTunnelPortTenantGet(uint32_t portNum, uint32_t tunnelId, ofdpaTunnelPortTenantStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelPortTenantGet(*args)

def ofdpaTunnelPortTenantNextGet(*args):
  """ofdpaTunnelPortTenantNextGet(uint32_t portNum, uint32_t tunnelId, uint32_t * nextTunnelId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelPortTenantNextGet(*args)

def ofdpaTunnelTenantCreate(*args):
  """ofdpaTunnelTenantCreate(uint32_t tunnelId, ofdpaTunnelTenantConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelTenantCreate(*args)

def ofdpaTunnelTenantDelete(*args):
  """ofdpaTunnelTenantDelete(uint32_t tunnelId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelTenantDelete(*args)

def ofdpaTunnelTenantGet(*args):
  """ofdpaTunnelTenantGet(uint32_t tunnelId, ofdpaTunnelTenantConfig_t config, ofdpaTunnelTenantStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelTenantGet(*args)

def ofdpaTunnelTenantNextGet(*args):
  """ofdpaTunnelTenantNextGet(uint32_t tunnelId, uint32_t * nextTunnelId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelTenantNextGet(*args)

def ofdpaTunnelNextHopCreate(*args):
  """ofdpaTunnelNextHopCreate(uint32_t nextHopId, ofdpaTunnelNextHopConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelNextHopCreate(*args)

def ofdpaTunnelNextHopDelete(*args):
  """ofdpaTunnelNextHopDelete(uint32_t nextHopId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelNextHopDelete(*args)

def ofdpaTunnelNextHopModify(*args):
  """ofdpaTunnelNextHopModify(uint32_t nextHopId, ofdpaTunnelNextHopConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelNextHopModify(*args)

def ofdpaTunnelNextHopGet(*args):
  """ofdpaTunnelNextHopGet(uint32_t nextHopId, ofdpaTunnelNextHopConfig_t config, ofdpaTunnelNextHopStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelNextHopGet(*args)

def ofdpaTunnelNextHopNextGet(*args):
  """ofdpaTunnelNextHopNextGet(uint32_t nextHopId, uint32_t * nextNextHopId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelNextHopNextGet(*args)

def ofdpaTunnelEcmpNextHopGroupCreate(*args):
  """ofdpaTunnelEcmpNextHopGroupCreate(uint32_t ecmpNextHopGroupId, ofdpaTunnelEcmpNextHopGroupConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelEcmpNextHopGroupCreate(*args)

def ofdpaTunnelEcmpNextHopGroupDelete(*args):
  """ofdpaTunnelEcmpNextHopGroupDelete(uint32_t ecmpNextHopGroupId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelEcmpNextHopGroupDelete(*args)

def ofdpaTunnelEcmpNextHopGroupGet(*args):
  """ofdpaTunnelEcmpNextHopGroupGet(uint32_t ecmpNextHopGroupId, ofdpaTunnelEcmpNextHopGroupConfig_t config, ofdpaTunnelEcmpNextHopGroupStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelEcmpNextHopGroupGet(*args)

def ofdpaTunnelEcmpNextHopGroupNextGet(*args):
  """ofdpaTunnelEcmpNextHopGroupNextGet(uint32_t ecmpNextHopGroupId, uint32_t * nextEcmpNextHopGroupId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelEcmpNextHopGroupNextGet(*args)

def ofdpaTunnelEcmpNextHopGroupMaxMembersGet(*args):
  """ofdpaTunnelEcmpNextHopGroupMaxMembersGet(uint32_t * maxMemberCount) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelEcmpNextHopGroupMaxMembersGet(*args)

def ofdpaTunnelEcmpNextHopGroupMemberAdd(*args):
  """ofdpaTunnelEcmpNextHopGroupMemberAdd(uint32_t ecmpNextHopGroupId, uint32_t nextHopId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelEcmpNextHopGroupMemberAdd(*args)

def ofdpaTunnelEcmpNextHopGroupMemberDelete(*args):
  """ofdpaTunnelEcmpNextHopGroupMemberDelete(uint32_t ecmpNextHopGroupId, uint32_t nextHopId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelEcmpNextHopGroupMemberDelete(*args)

def ofdpaTunnelEcmpNextHopGroupMemberGet(*args):
  """ofdpaTunnelEcmpNextHopGroupMemberGet(uint32_t ecmpNextHopListGroupId, uint32_t nextHopId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelEcmpNextHopGroupMemberGet(*args)

def ofdpaTunnelEcmpNextHopGroupMemberNextGet(*args):
  """ofdpaTunnelEcmpNextHopGroupMemberNextGet(uint32_t ecmpNextHopListGroupId, uint32_t nextHopId, uint32_t * nextNextHopId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaTunnelEcmpNextHopGroupMemberNextGet(*args)

def ofdpaPktSend(*args):
  """ofdpaPktSend(ofdpa_buffdesc pkt, uint32_t flags, uint32_t outPortNum, uint32_t inPortNum) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPktSend(*args)

def ofdpaMaxPktSizeGet(*args):
  """ofdpaMaxPktSizeGet(uint32_t * pktSize) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMaxPktSizeGet(*args)

def ofdpaClientEventSockBind():
  """ofdpaClientEventSockBind() -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaClientEventSockBind()

def ofdpaClientEventSockFdGet():
  """ofdpaClientEventSockFdGet() -> int"""
  return _OFDPA_python.ofdpaClientEventSockFdGet()

def ofdpaClientPktSockBind():
  """ofdpaClientPktSockBind() -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaClientPktSockBind()

def ofdpaClientPktSockFdGet():
  """ofdpaClientPktSockFdGet() -> int"""
  return _OFDPA_python.ofdpaClientPktSockFdGet()

def ofdpaPktReceive(*args):
  """ofdpaPktReceive(timeval timeout, ofdpaPacket_t pkt) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPktReceive(*args)

def ofdpaEventReceive(*args):
  """ofdpaEventReceive(timeval timeout) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaEventReceive(*args)

def ofdpaPortEventNextGet(*args):
  """ofdpaPortEventNextGet(ofdpaPortEvent_t eventData) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortEventNextGet(*args)

def ofdpaPortEventGet(*args):
  """ofdpaPortEventGet(ofdpaPortEvent_t eventData) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaPortEventGet(*args)

def ofdpaFlowEventNextGet(*args):
  """ofdpaFlowEventNextGet(ofdpaFlowEvent_t eventData) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowEventNextGet(*args)

def ofdpaOamEventNextGet(*args):
  """ofdpaOamEventNextGet(ofdpaOamEvent_t eventData) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamEventNextGet(*args)

def ofdpaFlowTableInfoGet(*args):
  """ofdpaFlowTableInfoGet(OFDPA_FLOW_TABLE_ID_t tableId, ofdpaFlowTableInfo_t info) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaFlowTableInfoGet(*args)

def ofdpaNumQueuesGet(*args):
  """ofdpaNumQueuesGet(uint32_t portNum, uint32_t * numQueues) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaNumQueuesGet(*args)

def ofdpaQueueStatsGet(*args):
  """ofdpaQueueStatsGet(uint32_t portNum, uint32_t queueId, ofdpaPortQueueStats_t stats) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaQueueStatsGet(*args)

def ofdpaQueueStatsClear(*args):
  """ofdpaQueueStatsClear(uint32_t portNum, uint32_t queueId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaQueueStatsClear(*args)

def ofdpaQueueRateSet(*args):
  """ofdpaQueueRateSet(uint32_t portNum, uint32_t queueId, uint32_t minRate, uint32_t maxRate) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaQueueRateSet(*args)

def ofdpaQueueRateGet(*args):
  """ofdpaQueueRateGet(uint32_t portNum, uint32_t queueId, uint32_t * minRate, uint32_t * maxRate) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaQueueRateGet(*args)

def ofdpaSourceMacLearningSet(*args):
  """ofdpaSourceMacLearningSet(OFDPA_CONTROL_t mode, ofdpaSrcMacLearnModeCfg_t srcMacLearnModeCfg) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaSourceMacLearningSet(*args)

def ofdpaSourceMacLearningGet(*args):
  """ofdpaSourceMacLearningGet(OFDPA_CONTROL_t * mode, ofdpaSrcMacLearnModeCfg_t srcMacLearnModeCfg) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaSourceMacLearningGet(*args)

def ofdpaGroupEntryInit(*args):
  """ofdpaGroupEntryInit(OFDPA_GROUP_ENTRY_TYPE_t groupType, ofdpaGroupEntry_t group) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupEntryInit(*args)

def ofdpaGroupBucketEntryInit(*args):
  """ofdpaGroupBucketEntryInit(OFDPA_GROUP_ENTRY_TYPE_t groupType, ofdpaGroupBucketEntry_t bucket) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaGroupBucketEntryInit(*args)

def ofdpaMeterAdd(*args):
  """ofdpaMeterAdd(uint32_t meterId, ofdpaMeterEntry_t meter) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMeterAdd(*args)

def ofdpaMeterDelete(*args):
  """ofdpaMeterDelete(uint32_t meterId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMeterDelete(*args)

def ofdpaMeterGet(*args):
  """ofdpaMeterGet(uint32_t meterId, ofdpaMeterEntry_t meter) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMeterGet(*args)

def ofdpaMeterNextGet(*args):
  """ofdpaMeterNextGet(uint32_t meterId, uint32_t * nextMeterId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMeterNextGet(*args)

def ofdpaMeterStatsGet(*args):
  """ofdpaMeterStatsGet(uint32_t meterId, ofdpaMeterEntryStats_t meterStats) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMeterStatsGet(*args)

def ofdpaMeterEntryInit(*args):
  """ofdpaMeterEntryInit(ofdpaMeterEntry_t meter) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMeterEntryInit(*args)

def ofdpaOamMegCreate(*args):
  """ofdpaOamMegCreate(uint32_t megIndex, ofdpaOamMegConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMegCreate(*args)

def ofdpaOamMegDelete(*args):
  """ofdpaOamMegDelete(uint32_t megIndex) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMegDelete(*args)

def ofdpaOamMegGet(*args):
  """ofdpaOamMegGet(uint32_t megIndex, ofdpaOamMegConfig_t config, ofdpaOamMegStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMegGet(*args)

def ofdpaOamMegNextGet(*args):
  """ofdpaOamMegNextGet(uint32_t megIndex, uint32_t * nextMegIndex) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMegNextGet(*args)

def ofdpaOamMepCreate(*args):
  """ofdpaOamMepCreate(uint32_t lmepId, ofdpaOamMepConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepCreate(*args)

def ofdpaOamMepDelete(*args):
  """ofdpaOamMepDelete(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepDelete(*args)

def ofdpaOamMepGet(*args):
  """ofdpaOamMepGet(uint32_t lmepId, ofdpaOamMepConfig_t config, ofdpaOamMepStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepGet(*args)

def ofdpaOamMepNextGet(*args):
  """ofdpaOamMepNextGet(uint32_t lmepId, uint32_t * nextLmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepNextGet(*args)

def ofdpaOamMipCreate(*args):
  """ofdpaOamMipCreate(uint32_t localMpId, ofdpaOamMipConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMipCreate(*args)

def ofdpaOamMipDelete(*args):
  """ofdpaOamMipDelete(uint32_t localMpId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMipDelete(*args)

def ofdpaOamMipGet(*args):
  """ofdpaOamMipGet(uint32_t localMpId, ofdpaOamMipConfig_t config, ofdpaOamMipStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMipGet(*args)

def ofdpaOamMipNextGet(*args):
  """ofdpaOamMipNextGet(uint32_t localMpId, uint32_t * nextLocalMpId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMipNextGet(*args)

def ofdpaOamRemoteMpCreate(*args):
  """ofdpaOamRemoteMpCreate(uint32_t remoteMpId, ofdpaOamRemoteMpConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamRemoteMpCreate(*args)

def ofdpaOamRemoteMpDelete(*args):
  """ofdpaOamRemoteMpDelete(uint32_t remoteMpId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamRemoteMpDelete(*args)

def ofdpaOamRemoteMpGet(*args):
  """ofdpaOamRemoteMpGet(uint32_t remoteMpId, ofdpaOamRemoteMpConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamRemoteMpGet(*args)

def ofdpaOamRemoteMpNextGet(*args):
  """ofdpaOamRemoteMpNextGet(uint32_t remoteMpId, uint32_t * nextRemoteMpId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamRemoteMpNextGet(*args)

def ofdpaOamMepCCMDatabaseEntryGet(*args):
  """ofdpaOamMepCCMDatabaseEntryGet(uint32_t lmepId, uint32_t remoteMepId, ofdpaOamCcmDatabaseEntry_t dbEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepCCMDatabaseEntryGet(*args)

def ofdpaOamMepCCMDatabaseEntryNextGet(*args):
  """ofdpaOamMepCCMDatabaseEntryNextGet(uint32_t lmepId, uint32_t remoteMepId, uint32_t * nextRemoteMepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepCCMDatabaseEntryNextGet(*args)

def ofdpaOamMepLtrEntryGet(*args):
  """ofdpaOamMepLtrEntryGet(uint32_t lmepId, uint32_t index, ofdpaOamLtrEntry_t ltrEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepLtrEntryGet(*args)

def ofdpaOamMepLtrEntryNextGet(*args):
  """ofdpaOamMepLtrEntryNextGet(uint32_t lmepId, uint32_t index, uint32_t * nextIndex) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepLtrEntryNextGet(*args)

def ofdpaOamOnDemandLmStart(*args):
  """ofdpaOamOnDemandLmStart(uint32_t lmepId, ofdpaOamOdLmConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOnDemandLmStart(*args)

def ofdpaOamOnDemandDmStart(*args):
  """ofdpaOamOnDemandDmStart(uint32_t lmepId, ofdpaOamOdDmConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOnDemandDmStart(*args)

def ofdpaOamMLPGroupCreate(*args):
  """ofdpaOamMLPGroupCreate(uint32_t index, ofdpaOamMLPGroupConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMLPGroupCreate(*args)

def ofdpaOamMLPGroupDelete(*args):
  """ofdpaOamMLPGroupDelete(uint32_t index) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMLPGroupDelete(*args)

def ofdpaOamMLPGroupGet(*args):
  """ofdpaOamMLPGroupGet(uint32_t index, ofdpaOamMLPGroupConfig_t config, ofdpaOamMLPGroupStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMLPGroupGet(*args)

def ofdpaOamMLPGroupNextGet(*args):
  """ofdpaOamMLPGroupNextGet(uint32_t index, uint32_t * nextIndex) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMLPGroupNextGet(*args)

def ofdpaOamMLPGroupRequest(*args):
  """ofdpaOamMLPGroupRequest(uint32_t index, OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_t request) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMLPGroupRequest(*args)

def ofdpaOamMepProtectionAdd(*args):
  """ofdpaOamMepProtectionAdd(uint32_t mlpGroupIndex, uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepProtectionAdd(*args)

def ofdpaOamMepProtectionRemove(*args):
  """ofdpaOamMepProtectionRemove(uint32_t mlpGroupIndex, uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepProtectionRemove(*args)

def ofdpaOamMepProtectionGet(*args):
  """ofdpaOamMepProtectionGet(uint32_t mlpGroupIndex, uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepProtectionGet(*args)

def ofdpaOamMepProtectionNextGet(*args):
  """ofdpaOamMepProtectionNextGet(uint32_t mlpGroupIndex, uint32_t lmepId, uint32_t * nextLmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamMepProtectionNextGet(*args)

def ofdpaMplsQosActionAdd(*args):
  """ofdpaMplsQosActionAdd(ofdpaMplsQosEntry_t mplsQosEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMplsQosActionAdd(*args)

def ofdpaMplsQosActionDelete(*args):
  """ofdpaMplsQosActionDelete(ofdpaMplsQosEntry_t mplsQosEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMplsQosActionDelete(*args)

def ofdpaMplsQosActionEntryGet(*args):
  """ofdpaMplsQosActionEntryGet(uint8_t qosIndex, uint8_t mpls_tc, ofdpaMplsQosEntry_t mplsQosEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMplsQosActionEntryGet(*args)

def ofdpaMplsQosEntryNextGet(*args):
  """ofdpaMplsQosEntryNextGet(ofdpaMplsQosEntry_t mplsQosEntry, ofdpaMplsQosEntry_t nextEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMplsQosEntryNextGet(*args)

def ofdpaMplsQosEntryInit(*args):
  """ofdpaMplsQosEntryInit(ofdpaMplsQosEntry_t mplsQosEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaMplsQosEntryInit(*args)

def ofdpaDropStatusAdd(*args):
  """ofdpaDropStatusAdd(ofdpaDropStatusEntry_t dropEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaDropStatusAdd(*args)

def ofdpaDropStatusDelete(*args):
  """ofdpaDropStatusDelete(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaDropStatusDelete(*args)

def ofdpaDropStatusGet(*args):
  """ofdpaDropStatusGet(uint32_t lmepId, ofdpaDropStatusEntry_t dropEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaDropStatusGet(*args)

def ofdpaDropStatusNextGet(*args):
  """ofdpaDropStatusNextGet(uint32_t lmepId, ofdpaDropStatusEntry_t nextDropEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaDropStatusNextGet(*args)

def ofdpaDropStatusActionGet(*args):
  """ofdpaDropStatusActionGet(uint32_t lmepId, uint8_t * dropAction) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaDropStatusActionGet(*args)

def ofdpaDropStatusEntryInit(*args):
  """ofdpaDropStatusEntryInit(ofdpaDropStatusEntry_t dropEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaDropStatusEntryInit(*args)

def ofdpaOamDataCounterAdd(*args):
  """ofdpaOamDataCounterAdd(uint32_t lmepId, uint8_t trafficClass) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamDataCounterAdd(*args)

def ofdpaOamDataCounterDelete(*args):
  """ofdpaOamDataCounterDelete(uint32_t lmepId, uint8_t trafficClass) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamDataCounterDelete(*args)

def ofdpaOamDataCounterStatusGet(*args):
  """ofdpaOamDataCounterStatusGet(uint32_t lmepId, uint8_t trafficClass, ofdpaOamDataCounterStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamDataCounterStatusGet(*args)

def ofdpaOamDataCounterGet(*args):
  """ofdpaOamDataCounterGet(ofdpaOamDataCounterIndex_t index, ofdpaOamDataCounterStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamDataCounterGet(*args)

def ofdpaOamDataCounterNextGet(*args):
  """ofdpaOamDataCounterNextGet(ofdpaOamDataCounterIndex_t index, ofdpaOamDataCounterIndex_t nextIndex, ofdpaOamDataCounterStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamDataCounterNextGet(*args)

def ofdpaOamDataCountersLMGet(*args):
  """ofdpaOamDataCountersLMGet(ofdpaOamDataCounterIndex_t index, uint32_t * TxFCl, uint32_t * RxFCl) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamDataCountersLMGet(*args)

def ofdpaOamDataCountersLMClear(*args):
  """ofdpaOamDataCountersLMClear(ofdpaOamDataCounterIndex_t index) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamDataCountersLMClear(*args)

def ofdpaRemarkActionAdd(*args):
  """ofdpaRemarkActionAdd(ofdpaRemarkActionEntry_t remarkEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaRemarkActionAdd(*args)

def ofdpaRemarkActionDelete(*args):
  """ofdpaRemarkActionDelete(ofdpaRemarkActionEntry_t remarkEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaRemarkActionDelete(*args)

def ofdpaRemarkActionEntryGet(*args):
  """ofdpaRemarkActionEntryGet(ofdpaRemarkActionEntry_t remarkEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaRemarkActionEntryGet(*args)

def ofdpaRemarkEntryNextGet(*args):
  """ofdpaRemarkEntryNextGet(ofdpaRemarkActionEntry_t remarkEntry, ofdpaRemarkActionEntry_t nextEntry) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaRemarkEntryNextGet(*args)

def ofdpaDebugLvl(*args):
  """ofdpaDebugLvl(int lvl) -> int"""
  return _OFDPA_python.ofdpaDebugLvl(*args)

def ofdpaDebugLvlGet():
  """ofdpaDebugLvlGet() -> int"""
  return _OFDPA_python.ofdpaDebugLvlGet()

def ofdpaComponentNameGet(*args):
  """ofdpaComponentNameGet(int component, ofdpa_buffdesc name) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaComponentNameGet(*args)

def ofdpaDebugComponentSet(*args):
  """ofdpaDebugComponentSet(int component, int enable) -> int"""
  return _OFDPA_python.ofdpaDebugComponentSet(*args)

def ofdpaDebugComponentGet(*args):
  """ofdpaDebugComponentGet(int component) -> int"""
  return _OFDPA_python.ofdpaDebugComponentGet(*args)

def ofdpaBcmCommand(*args):
  """ofdpaBcmCommand(ofdpa_buffdesc buffer) -> int"""
  return _OFDPA_python.ofdpaBcmCommand(*args)

def ofdpaDevshellCommand(*args):
  """ofdpaDevshellCommand(ofdpa_buffdesc buffer) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaDevshellCommand(*args)

def ofdpaOamLbCreate(*args):
  """ofdpaOamLbCreate(uint32_t lmepId, ofdpaOamLbConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamLbCreate(*args)

def ofdpaOamLbStart(*args):
  """ofdpaOamLbStart(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamLbStart(*args)

def ofdpaOamLbStop(*args):
  """ofdpaOamLbStop(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamLbStop(*args)

def ofdpaOamLbGet(*args):
  """ofdpaOamLbGet(uint32_t lmepId, ofdpaOamLbConfig_t config, ofdpaOamLbStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamLbGet(*args)

def ofdpaOamProLmCreate(*args):
  """ofdpaOamProLmCreate(uint32_t lmepId, ofdpaOamProLmConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProLmCreate(*args)

def ofdpaOamProLmDelete(*args):
  """ofdpaOamProLmDelete(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProLmDelete(*args)

def ofdpaOamProLmGet(*args):
  """ofdpaOamProLmGet(uint32_t lmepId, ofdpaOamProLmConfig_t config, ofdpaOamProLmStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProLmGet(*args)

def ofdpaOamProLmCountersGet(*args):
  """ofdpaOamProLmCountersGet(uint32_t lmepId, ofdpaOamProLmCounters_t counters) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProLmCountersGet(*args)

def ofdpaOamProDmCreate(*args):
  """ofdpaOamProDmCreate(uint32_t lmepId, ofdpaOamProDmConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProDmCreate(*args)

def ofdpaOamProDmDelete(*args):
  """ofdpaOamProDmDelete(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProDmDelete(*args)

def ofdpaOamProDmGet(*args):
  """ofdpaOamProDmGet(uint32_t lmepId, ofdpaOamProDmConfig_t config, ofdpaOamProDmStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProDmGet(*args)

def ofdpaOamProDmCountersGet(*args):
  """ofdpaOamProDmCountersGet(uint32_t lmepId, ofdpaOamProDmCounters_t counters) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProDmCountersGet(*args)

def ofdpaOamOdLmCreate(*args):
  """ofdpaOamOdLmCreate(uint32_t lmepId, ofdpaOamOdLmConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdLmCreate(*args)

def ofdpaOamOdLmDelete(*args):
  """ofdpaOamOdLmDelete(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdLmDelete(*args)

def ofdpaOamOdLmGet(*args):
  """ofdpaOamOdLmGet(uint32_t lmepId, ofdpaOamOdLmConfig_t config, ofdpaOamOdLmStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdLmGet(*args)

def ofdpaOamOdLmCountersGet(*args):
  """ofdpaOamOdLmCountersGet(uint32_t lmepId, ofdpaOamOdLmSnapshot_t counters) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdLmCountersGet(*args)

def ofdpaOamOdDmCreate(*args):
  """ofdpaOamOdDmCreate(uint32_t lmepId, ofdpaOamOdDmConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdDmCreate(*args)

def ofdpaOamOdDmDelete(*args):
  """ofdpaOamOdDmDelete(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdDmDelete(*args)

def ofdpaOamOdDmGet(*args):
  """ofdpaOamOdDmGet(uint32_t lmepId, ofdpaOamOdDmConfig_t config, ofdpaOamOdDmStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdDmGet(*args)

def ofdpaOamOdDmCountersGet(*args):
  """ofdpaOamOdDmCountersGet(uint32_t lmepId, ofdpaOamOdDmSnapshot_t counters) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdDmCountersGet(*args)

def ofdpaOamOdLmStart(*args):
  """ofdpaOamOdLmStart(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdLmStart(*args)

def ofdpaOamOdLmStop(*args):
  """ofdpaOamOdLmStop(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdLmStop(*args)

def ofdpaOamOdDmStart(*args):
  """ofdpaOamOdDmStart(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdDmStart(*args)

def ofdpaOamOdDmStop(*args):
  """ofdpaOamOdDmStop(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamOdDmStop(*args)

def ofdpaOamProDmStart(*args):
  """ofdpaOamProDmStart(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProDmStart(*args)

def ofdpaOamProDmStop(*args):
  """ofdpaOamProDmStop(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProDmStop(*args)

def ofdpaOamProLmEnable(*args):
  """ofdpaOamProLmEnable(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProLmEnable(*args)

def ofdpaOamProLmDisable(*args):
  """ofdpaOamProLmDisable(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamProLmDisable(*args)

def ofdpaOamLtStart(*args):
  """ofdpaOamLtStart(uint32_t lmepId, ofdpaOamLtConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamLtStart(*args)

def ofdpaOamLtGet(*args):
  """ofdpaOamLtGet(uint32_t lmepId, ofdpaOamLtConfig_t config, ofdpaOamLtStatus_t status) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamLtGet(*args)

def ofdpaOamLtResultNextGet(*args):
  """ofdpaOamLtResultNextGet(uint32_t lmepId, uint32_t sequenceNum, uint32_t receiveOrder, ofdpaOamLtrEntry_t ltResult) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamLtResultNextGet(*args)

def ofdpaOamCsfEnable(*args):
  """ofdpaOamCsfEnable(uint32_t lmepId, ofdpaOamCsfConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamCsfEnable(*args)

def ofdpaOamCsfDisable(*args):
  """ofdpaOamCsfDisable(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamCsfDisable(*args)

def ofdpaOamAisEnable(*args):
  """ofdpaOamAisEnable(uint32_t lmepId, ofdpaOamAisConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamAisEnable(*args)

def ofdpaOamAisDisable(*args):
  """ofdpaOamAisDisable(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamAisDisable(*args)

def ofdpaOamAisConfigGet(*args):
  """ofdpaOamAisConfigGet(uint32_t lmepId, ofdpaOamAisConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamAisConfigGet(*args)

def ofdpaOamLckEnable(*args):
  """ofdpaOamLckEnable(uint32_t lmepId, ofdpaOamLckConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamLckEnable(*args)

def ofdpaOamLckDisable(*args):
  """ofdpaOamLckDisable(uint32_t lmepId) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamLckDisable(*args)

def ofdpaOamLckConfigGet(*args):
  """ofdpaOamLckConfigGet(uint32_t lmepId, ofdpaOamLckConfig_t config) -> OFDPA_ERROR_t"""
  return _OFDPA_python.ofdpaOamLckConfigGet(*args)
OFDPA_E_NONE = _OFDPA_python.OFDPA_E_NONE
OFDPA_E_RPC = _OFDPA_python.OFDPA_E_RPC
OFDPA_E_INTERNAL = _OFDPA_python.OFDPA_E_INTERNAL
OFDPA_E_PARAM = _OFDPA_python.OFDPA_E_PARAM
OFDPA_E_ERROR = _OFDPA_python.OFDPA_E_ERROR
OFDPA_E_FULL = _OFDPA_python.OFDPA_E_FULL
OFDPA_E_EXISTS = _OFDPA_python.OFDPA_E_EXISTS
OFDPA_E_TIMEOUT = _OFDPA_python.OFDPA_E_TIMEOUT
OFDPA_E_FAIL = _OFDPA_python.OFDPA_E_FAIL
OFDPA_E_DISABLED = _OFDPA_python.OFDPA_E_DISABLED
OFDPA_E_UNAVAIL = _OFDPA_python.OFDPA_E_UNAVAIL
OFDPA_E_NOT_FOUND = _OFDPA_python.OFDPA_E_NOT_FOUND
OFDPA_E_EMPTY = _OFDPA_python.OFDPA_E_EMPTY
OFDPA_E_REQUEST_DENIED = _OFDPA_python.OFDPA_E_REQUEST_DENIED
OFDPA_NOT_IMPLEMENTED_YET = _OFDPA_python.OFDPA_NOT_IMPLEMENTED_YET
OFDPA_FEATURE_INVALID = _OFDPA_python.OFDPA_FEATURE_INVALID
OFDPA_FEATURE_VXLAN = _OFDPA_python.OFDPA_FEATURE_VXLAN
OFDPA_FEATURE_ACLIPV6MAC = _OFDPA_python.OFDPA_FEATURE_ACLIPV6MAC
OFDPA_FEATURE_MPLSTHREELABELS = _OFDPA_python.OFDPA_FEATURE_MPLSTHREELABELS
OFDPA_FEATURE_MPLSSUPPORTED = _OFDPA_python.OFDPA_FEATURE_MPLSSUPPORTED
OFDPA_FEATURE_MPLSECMP = _OFDPA_python.OFDPA_FEATURE_MPLSECMP
OFDPA_FEATURE_OAM = _OFDPA_python.OFDPA_FEATURE_OAM
OFDPA_FEATURE_SERVICE_METER = _OFDPA_python.OFDPA_FEATURE_SERVICE_METER
OFDPA_DOT1AG_MPLS_TP_CCM_SUPPORT = _OFDPA_python.OFDPA_DOT1AG_MPLS_TP_CCM_SUPPORT
OFDPA_DOT1AG_LTR_SORT_FEATURE_ID = _OFDPA_python.OFDPA_DOT1AG_LTR_SORT_FEATURE_ID
OFDPA_FEATURE_MAX = _OFDPA_python.OFDPA_FEATURE_MAX
OFDPA_FALSE = _OFDPA_python.OFDPA_FALSE
OFDPA_TRUE = _OFDPA_python.OFDPA_TRUE
OFDPA_MAC_ADDR_LEN = _OFDPA_python.OFDPA_MAC_ADDR_LEN
OFDPA_IP_ADDR_LEN = _OFDPA_python.OFDPA_IP_ADDR_LEN
OFDPA_PORT_CONTROLLER = _OFDPA_python.OFDPA_PORT_CONTROLLER
OFDPA_PORT_LOCAL = _OFDPA_python.OFDPA_PORT_LOCAL
OFDPA_VID_FIELD_MASK = _OFDPA_python.OFDPA_VID_FIELD_MASK
OFDPA_VID_EXACT_MASK = _OFDPA_python.OFDPA_VID_EXACT_MASK
OFDPA_VID_NONE = _OFDPA_python.OFDPA_VID_NONE
OFDPA_VID_PRESENT = _OFDPA_python.OFDPA_VID_PRESENT
OFDPA_INPORT_EXACT_MASK = _OFDPA_python.OFDPA_INPORT_EXACT_MASK
OFDPA_INPORT_FIELD_MASK = _OFDPA_python.OFDPA_INPORT_FIELD_MASK
OFDPA_INPORT_INDEX_MASK = _OFDPA_python.OFDPA_INPORT_INDEX_MASK
OFDPA_INPORT_TYPE_MASK = _OFDPA_python.OFDPA_INPORT_TYPE_MASK
OFDPA_ETHERTYPE_EXACT_MASK = _OFDPA_python.OFDPA_ETHERTYPE_EXACT_MASK
OFDPA_ETHERTYPE_ALL_MASK = _OFDPA_python.OFDPA_ETHERTYPE_ALL_MASK
OFDPA_LMEP_ID_EXACT_MASK = _OFDPA_python.OFDPA_LMEP_ID_EXACT_MASK
OFDPA_IPV4_ADDR_EXACT_MASK = _OFDPA_python.OFDPA_IPV4_ADDR_EXACT_MASK
OFDPA_IPV4_ADDR_FIELD_MASK = _OFDPA_python.OFDPA_IPV4_ADDR_FIELD_MASK
OFDPA_OAM_Y1731_OPCODE_EXACT_MASK = _OFDPA_python.OFDPA_OAM_Y1731_OPCODE_EXACT_MASK
OFDPA_OAM_Y1731_OPCODE_ALL_MASK = _OFDPA_python.OFDPA_OAM_Y1731_OPCODE_ALL_MASK
OFDPA_OAM_Y1731_MDL_EXACT_MASK = _OFDPA_python.OFDPA_OAM_Y1731_MDL_EXACT_MASK
OFDPA_OAM_Y1731_MDL_ALL_MASK = _OFDPA_python.OFDPA_OAM_Y1731_MDL_ALL_MASK
OFDPA_ZERO_MASK = _OFDPA_python.OFDPA_ZERO_MASK
OFDPA_VLAN_DEI_VALUE_MASK = _OFDPA_python.OFDPA_VLAN_DEI_VALUE_MASK
OFDPA_VLAN_DEI_MAX_VALUE = _OFDPA_python.OFDPA_VLAN_DEI_MAX_VALUE
OFDPA_VRF_VALUE_MASK = _OFDPA_python.OFDPA_VRF_VALUE_MASK
OFDPA_ECN_VALUE_MASK = _OFDPA_python.OFDPA_ECN_VALUE_MASK
OFDPA_ECN_MAX_VALUE = _OFDPA_python.OFDPA_ECN_MAX_VALUE
OFDPA_DSCP_VALUE_MASK = _OFDPA_python.OFDPA_DSCP_VALUE_MASK
OFDPA_DSCP_MAX_VALUE = _OFDPA_python.OFDPA_DSCP_MAX_VALUE
OFDPA_VLAN_PCP_MAX_VALUE = _OFDPA_python.OFDPA_VLAN_PCP_MAX_VALUE
OFDPA_MPLS_TC_MAX_VALUE = _OFDPA_python.OFDPA_MPLS_TC_MAX_VALUE
OFDPA_MDL_MAX_VALUE = _OFDPA_python.OFDPA_MDL_MAX_VALUE
OFDPA_TRAFFIC_CLASS_MAX_VALUE = _OFDPA_python.OFDPA_TRAFFIC_CLASS_MAX_VALUE
OFDPA_L2_POLICER_METERID_MIN_VALUE = _OFDPA_python.OFDPA_L2_POLICER_METERID_MIN_VALUE
OFDPA_MPLS_NEXT_LABEL_GAL_EXACT_MASK = _OFDPA_python.OFDPA_MPLS_NEXT_LABEL_GAL_EXACT_MASK
OFDPA_MPLS_NEXT_LABEL_GAL_ALL_MASK = _OFDPA_python.OFDPA_MPLS_NEXT_LABEL_GAL_ALL_MASK
OFDPA_MPLS_LABEL_GAL = _OFDPA_python.OFDPA_MPLS_LABEL_GAL
OFDPA_MPLS_DATA_FIRST_NIBBLE_EXACT_MASK = _OFDPA_python.OFDPA_MPLS_DATA_FIRST_NIBBLE_EXACT_MASK
OFDPA_MPLS_DATA_FIRST_NIBBLE_ALL_MASK = _OFDPA_python.OFDPA_MPLS_DATA_FIRST_NIBBLE_ALL_MASK
OFDPA_MPLS_DATA_FIRST_NIBBLE_IPV4 = _OFDPA_python.OFDPA_MPLS_DATA_FIRST_NIBBLE_IPV4
OFDPA_MPLS_DATA_FIRST_NIBBLE_IPV6 = _OFDPA_python.OFDPA_MPLS_DATA_FIRST_NIBBLE_IPV6
OFDPA_MPLS_CHANNEL_TYPE_EXACT_MASK = _OFDPA_python.OFDPA_MPLS_CHANNEL_TYPE_EXACT_MASK
OFDPA_MPLS_CHANNEL_TYPE_ALL_MASK = _OFDPA_python.OFDPA_MPLS_CHANNEL_TYPE_ALL_MASK
OFDPA_MPLS_ACH_CHANNEL_TYPE = _OFDPA_python.OFDPA_MPLS_ACH_CHANNEL_TYPE
OFDPA_MPLS_TTL_EXACT_MASK = _OFDPA_python.OFDPA_MPLS_TTL_EXACT_MASK
ODFPA_PROTECTION_PATH = _OFDPA_python.ODFPA_PROTECTION_PATH
ODFPA_WORKING_PATH = _OFDPA_python.ODFPA_WORKING_PATH
OFDPA_PORT_TYPE_PHYSICAL = _OFDPA_python.OFDPA_PORT_TYPE_PHYSICAL
OFDPA_PORT_TYPE_LOGICAL_TUNNEL = _OFDPA_python.OFDPA_PORT_TYPE_LOGICAL_TUNNEL
OFDPA_PORT_TYPE_OAM_PROTECTION_LIVENESS_LOGICAL_PORT = _OFDPA_python.OFDPA_PORT_TYPE_OAM_PROTECTION_LIVENESS_LOGICAL_PORT
OFDPA_MPLS_L2_PORT_TYPE_VPWS_LOCAL = _OFDPA_python.OFDPA_MPLS_L2_PORT_TYPE_VPWS_LOCAL
OFDPA_MPLS_L2_PORT_TYPE_VPLS_LOCAL = _OFDPA_python.OFDPA_MPLS_L2_PORT_TYPE_VPLS_LOCAL
OFDPA_MPLS_L2_PORT_TYPE_VPWS_NW = _OFDPA_python.OFDPA_MPLS_L2_PORT_TYPE_VPWS_NW
OFDPA_MPLS_L2_PORT_TYPE_VPLS_NW = _OFDPA_python.OFDPA_MPLS_L2_PORT_TYPE_VPLS_NW
OFDPA_MPLS_L2_PORT_EXACT_MASK = _OFDPA_python.OFDPA_MPLS_L2_PORT_EXACT_MASK
OFDPA_MPLS_L2_PORT_FIELD_MASK = _OFDPA_python.OFDPA_MPLS_L2_PORT_FIELD_MASK
OFDPA_MPLS_L2_PORT_INDEX_MASK = _OFDPA_python.OFDPA_MPLS_L2_PORT_INDEX_MASK
OFDPA_MPLS_L2_PORT_TYPE_MASK = _OFDPA_python.OFDPA_MPLS_L2_PORT_TYPE_MASK
OFDPA_QOS_GREEN = _OFDPA_python.OFDPA_QOS_GREEN
OFDPA_QOS_YELLOW = _OFDPA_python.OFDPA_QOS_YELLOW
OFDPA_QOS_RED = _OFDPA_python.OFDPA_QOS_RED
OFDPA_QOS_RESERVED = _OFDPA_python.OFDPA_QOS_RESERVED
class ofdpaMacAddr_t(_object):
    """Proxy of C ofdpaMacAddr_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMacAddr_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMacAddr_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["addr"] = _OFDPA_python.ofdpaMacAddr_t_addr_set
    __swig_getmethods__["addr"] = _OFDPA_python.ofdpaMacAddr_t_addr_get
    if _newclass:addr = _swig_property(_OFDPA_python.ofdpaMacAddr_t_addr_get, _OFDPA_python.ofdpaMacAddr_t_addr_set)
    def __init__(self): 
        """__init__(ofdpaMacAddr_s self) -> ofdpaMacAddr_t"""
        this = _OFDPA_python.new_ofdpaMacAddr_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMacAddr_t
    __del__ = lambda self : None;
ofdpaMacAddr_t_swigregister = _OFDPA_python.ofdpaMacAddr_t_swigregister
ofdpaMacAddr_t_swigregister(ofdpaMacAddr_t)

class ofdpa_buffdesc(_object):
    """Proxy of C ofdpa_buffdesc struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpa_buffdesc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpa_buffdesc, name)
    __repr__ = _swig_repr
    __swig_setmethods__["size"] = _OFDPA_python.ofdpa_buffdesc_size_set
    __swig_getmethods__["size"] = _OFDPA_python.ofdpa_buffdesc_size_get
    if _newclass:size = _swig_property(_OFDPA_python.ofdpa_buffdesc_size_get, _OFDPA_python.ofdpa_buffdesc_size_set)
    __swig_setmethods__["pstart"] = _OFDPA_python.ofdpa_buffdesc_pstart_set
    __swig_getmethods__["pstart"] = _OFDPA_python.ofdpa_buffdesc_pstart_get
    if _newclass:pstart = _swig_property(_OFDPA_python.ofdpa_buffdesc_pstart_get, _OFDPA_python.ofdpa_buffdesc_pstart_set)
    def __init__(self): 
        """__init__(ofdpa_buffdesc self) -> ofdpa_buffdesc"""
        this = _OFDPA_python.new_ofdpa_buffdesc()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpa_buffdesc
    __del__ = lambda self : None;
ofdpa_buffdesc_swigregister = _OFDPA_python.ofdpa_buffdesc_swigregister
ofdpa_buffdesc_swigregister(ofdpa_buffdesc)

OFDPA_DISABLE = _OFDPA_python.OFDPA_DISABLE
OFDPA_ENABLE = _OFDPA_python.OFDPA_ENABLE
OFDPA_COMPONENT_FIRST = _OFDPA_python.OFDPA_COMPONENT_FIRST
OFDPA_COMPONENT_API = _OFDPA_python.OFDPA_COMPONENT_API
OFDPA_COMPONENT_MAPPING = _OFDPA_python.OFDPA_COMPONENT_MAPPING
OFDPA_COMPONENT_RPC = _OFDPA_python.OFDPA_COMPONENT_RPC
OFDPA_COMPONENT_OFDB = _OFDPA_python.OFDPA_COMPONENT_OFDB
OFDPA_COMPONENT_DATAPATH = _OFDPA_python.OFDPA_COMPONENT_DATAPATH
OFDPA_COMPONENT_G8131 = _OFDPA_python.OFDPA_COMPONENT_G8131
OFDPA_COMPONENT_Y1731 = _OFDPA_python.OFDPA_COMPONENT_Y1731
OFDPA_COMPONENT_MAX = _OFDPA_python.OFDPA_COMPONENT_MAX
OFDPA_DEBUG_ALWAYS = _OFDPA_python.OFDPA_DEBUG_ALWAYS
OFDPA_DEBUG_BASIC = _OFDPA_python.OFDPA_DEBUG_BASIC
OFDPA_DEBUG_VERBOSE = _OFDPA_python.OFDPA_DEBUG_VERBOSE
OFDPA_DEBUG_VERY_VERBOSE = _OFDPA_python.OFDPA_DEBUG_VERY_VERBOSE
OFDPA_DEBUG_TOO_VERBOSE = _OFDPA_python.OFDPA_DEBUG_TOO_VERBOSE
OFDPA_DEBUG_MAX = _OFDPA_python.OFDPA_DEBUG_MAX
OFDPA_TUNNEL_ID_EXACT_MASK = _OFDPA_python.OFDPA_TUNNEL_ID_EXACT_MASK
OFDPA_TUNNEL_ID_FIELD_MASK = _OFDPA_python.OFDPA_TUNNEL_ID_FIELD_MASK
OFDPA_TUNNEL_ID_INDEX_MASK = _OFDPA_python.OFDPA_TUNNEL_ID_INDEX_MASK
OFDPA_TUNNEL_ID_TYPE_MASK = _OFDPA_python.OFDPA_TUNNEL_ID_TYPE_MASK
OFDPA_TUNNELID_TYPE_DATA_CENTER_OVERLAY = _OFDPA_python.OFDPA_TUNNELID_TYPE_DATA_CENTER_OVERLAY
OFDPA_TUNNELID_TYPE_MPLS_TP = _OFDPA_python.OFDPA_TUNNELID_TYPE_MPLS_TP
OFDPA_ACTION_TABLE_TYPE_MPLS_SET_QOS = _OFDPA_python.OFDPA_ACTION_TABLE_TYPE_MPLS_SET_QOS
OFDPA_ACTION_TABLE_TYPE_OAM_DATAPLANE_COUNTER = _OFDPA_python.OFDPA_ACTION_TABLE_TYPE_OAM_DATAPLANE_COUNTER
OFDPA_ACTION_TABLE_TYPE_DROP_STATUS = _OFDPA_python.OFDPA_ACTION_TABLE_TYPE_DROP_STATUS
OFDPA_ACTION_TABLE_TYPE_MPLS_VPN_LABEL_REMARK = _OFDPA_python.OFDPA_ACTION_TABLE_TYPE_MPLS_VPN_LABEL_REMARK
OFDPA_ACTION_TABLE_TYPE_MPLS_TUNNEL_LABEL_REMARK = _OFDPA_python.OFDPA_ACTION_TABLE_TYPE_MPLS_TUNNEL_LABEL_REMARK
OFDPA_MPLS_TYPE_VPWS = _OFDPA_python.OFDPA_MPLS_TYPE_VPWS
OFDPA_MPLS_TYPE_VPLS = _OFDPA_python.OFDPA_MPLS_TYPE_VPLS
OFDPA_MPLS_TYPE_OAM = _OFDPA_python.OFDPA_MPLS_TYPE_OAM
OFDPA_MPLS_TYPE_L3_UNICAST = _OFDPA_python.OFDPA_MPLS_TYPE_L3_UNICAST
OFDPA_MPLS_TYPE_L3_MULTICAST = _OFDPA_python.OFDPA_MPLS_TYPE_L3_MULTICAST
OFDPA_MPLS_TYPE_L3_PHP = _OFDPA_python.OFDPA_MPLS_TYPE_L3_PHP
OFDPA_FLOW_TABLE_ID_INGRESS_PORT = _OFDPA_python.OFDPA_FLOW_TABLE_ID_INGRESS_PORT
OFDPA_FLOW_TABLE_ID_PORT_DSCP_TRUST = _OFDPA_python.OFDPA_FLOW_TABLE_ID_PORT_DSCP_TRUST
OFDPA_FLOW_TABLE_ID_PORT_PCP_TRUST = _OFDPA_python.OFDPA_FLOW_TABLE_ID_PORT_PCP_TRUST
OFDPA_FLOW_TABLE_ID_TUNNEL_DSCP_TRUST = _OFDPA_python.OFDPA_FLOW_TABLE_ID_TUNNEL_DSCP_TRUST
OFDPA_FLOW_TABLE_ID_TUNNEL_PCP_TRUST = _OFDPA_python.OFDPA_FLOW_TABLE_ID_TUNNEL_PCP_TRUST
OFDPA_FLOW_TABLE_ID_INJECTED_OAM = _OFDPA_python.OFDPA_FLOW_TABLE_ID_INJECTED_OAM
OFDPA_FLOW_TABLE_ID_VLAN = _OFDPA_python.OFDPA_FLOW_TABLE_ID_VLAN
OFDPA_FLOW_TABLE_ID_VLAN_1 = _OFDPA_python.OFDPA_FLOW_TABLE_ID_VLAN_1
OFDPA_FLOW_TABLE_ID_MAINTENANCE_POINT = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MAINTENANCE_POINT
OFDPA_FLOW_TABLE_ID_MPLS_L2_PORT = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MPLS_L2_PORT
OFDPA_FLOW_TABLE_ID_MPLS_DSCP_TRUST = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MPLS_DSCP_TRUST
OFDPA_FLOW_TABLE_ID_MPLS_PCP_TRUST = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MPLS_PCP_TRUST
OFDPA_FLOW_TABLE_ID_L2_POLICER = _OFDPA_python.OFDPA_FLOW_TABLE_ID_L2_POLICER
OFDPA_FLOW_TABLE_ID_L2_POLICER_ACTIONS = _OFDPA_python.OFDPA_FLOW_TABLE_ID_L2_POLICER_ACTIONS
OFDPA_FLOW_TABLE_ID_TERMINATION_MAC = _OFDPA_python.OFDPA_FLOW_TABLE_ID_TERMINATION_MAC
OFDPA_FLOW_TABLE_ID_L3_TYPE = _OFDPA_python.OFDPA_FLOW_TABLE_ID_L3_TYPE
OFDPA_FLOW_TABLE_ID_MPLS_0 = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MPLS_0
OFDPA_FLOW_TABLE_ID_MPLS_1 = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MPLS_1
OFDPA_FLOW_TABLE_ID_MPLS_2 = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MPLS_2
OFDPA_FLOW_TABLE_ID_MPLS_MAINTENANCE_POINT = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MPLS_MAINTENANCE_POINT
OFDPA_FLOW_TABLE_ID_MPLS_L3_TYPE = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MPLS_L3_TYPE
OFDPA_FLOW_TABLE_ID_MPLS_TYPE = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MPLS_TYPE
OFDPA_FLOW_TABLE_ID_UNICAST_ROUTING = _OFDPA_python.OFDPA_FLOW_TABLE_ID_UNICAST_ROUTING
OFDPA_FLOW_TABLE_ID_MULTICAST_ROUTING = _OFDPA_python.OFDPA_FLOW_TABLE_ID_MULTICAST_ROUTING
OFDPA_FLOW_TABLE_ID_BRIDGING = _OFDPA_python.OFDPA_FLOW_TABLE_ID_BRIDGING
OFDPA_FLOW_TABLE_ID_ACL_POLICY = _OFDPA_python.OFDPA_FLOW_TABLE_ID_ACL_POLICY
OFDPA_FLOW_TABLE_ID_COLOR_BASED_ACTIONS = _OFDPA_python.OFDPA_FLOW_TABLE_ID_COLOR_BASED_ACTIONS
OFDPA_FLOW_TABLE_ID_EGRESS_VLAN = _OFDPA_python.OFDPA_FLOW_TABLE_ID_EGRESS_VLAN
OFDPA_FLOW_TABLE_ID_EGRESS_VLAN_1 = _OFDPA_python.OFDPA_FLOW_TABLE_ID_EGRESS_VLAN_1
OFDPA_FLOW_TABLE_ID_EGRESS_MAINTENANCE_POINT = _OFDPA_python.OFDPA_FLOW_TABLE_ID_EGRESS_MAINTENANCE_POINT
OFDPA_FLOW_TABLE_ID_EGRESS_DSCP_PCP_REMARK = _OFDPA_python.OFDPA_FLOW_TABLE_ID_EGRESS_DSCP_PCP_REMARK
OFDPA_FLOW_TABLE_ID_EGRESS_TPID = _OFDPA_python.OFDPA_FLOW_TABLE_ID_EGRESS_TPID
OFDPA_FLOW_TABLE_ID_SA_LOOKUP = _OFDPA_python.OFDPA_FLOW_TABLE_ID_SA_LOOKUP
class ofdpaIngressPortFlowMatch_t(_object):
    """Proxy of C ofdpaIngressPortFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaIngressPortFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaIngressPortFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["inPort"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_inPort_set
    __swig_getmethods__["inPort"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_inPort_get
    if _newclass:inPort = _swig_property(_OFDPA_python.ofdpaIngressPortFlowMatch_t_inPort_get, _OFDPA_python.ofdpaIngressPortFlowMatch_t_inPort_set)
    __swig_setmethods__["inPortMask"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_inPortMask_set
    __swig_getmethods__["inPortMask"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_inPortMask_get
    if _newclass:inPortMask = _swig_property(_OFDPA_python.ofdpaIngressPortFlowMatch_t_inPortMask_get, _OFDPA_python.ofdpaIngressPortFlowMatch_t_inPortMask_set)
    __swig_setmethods__["tunnelId"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_tunnelId_set
    __swig_getmethods__["tunnelId"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_tunnelId_get
    if _newclass:tunnelId = _swig_property(_OFDPA_python.ofdpaIngressPortFlowMatch_t_tunnelId_get, _OFDPA_python.ofdpaIngressPortFlowMatch_t_tunnelId_set)
    __swig_setmethods__["tunnelIdMask"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_tunnelIdMask_set
    __swig_getmethods__["tunnelIdMask"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_tunnelIdMask_get
    if _newclass:tunnelIdMask = _swig_property(_OFDPA_python.ofdpaIngressPortFlowMatch_t_tunnelIdMask_get, _OFDPA_python.ofdpaIngressPortFlowMatch_t_tunnelIdMask_set)
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaIngressPortFlowMatch_t_etherType_get, _OFDPA_python.ofdpaIngressPortFlowMatch_t_etherType_set)
    __swig_setmethods__["etherTypeMask"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_etherTypeMask_set
    __swig_getmethods__["etherTypeMask"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_etherTypeMask_get
    if _newclass:etherTypeMask = _swig_property(_OFDPA_python.ofdpaIngressPortFlowMatch_t_etherTypeMask_get, _OFDPA_python.ofdpaIngressPortFlowMatch_t_etherTypeMask_set)
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaIngressPortFlowMatch_t_lmepId_get, _OFDPA_python.ofdpaIngressPortFlowMatch_t_lmepId_set)
    __swig_setmethods__["lmepIdMask"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_lmepIdMask_set
    __swig_getmethods__["lmepIdMask"] = _OFDPA_python.ofdpaIngressPortFlowMatch_t_lmepIdMask_get
    if _newclass:lmepIdMask = _swig_property(_OFDPA_python.ofdpaIngressPortFlowMatch_t_lmepIdMask_get, _OFDPA_python.ofdpaIngressPortFlowMatch_t_lmepIdMask_set)
    def __init__(self): 
        """__init__(ofdpaIngressPortFlowMatch_s self) -> ofdpaIngressPortFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaIngressPortFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaIngressPortFlowMatch_t
    __del__ = lambda self : None;
ofdpaIngressPortFlowMatch_t_swigregister = _OFDPA_python.ofdpaIngressPortFlowMatch_t_swigregister
ofdpaIngressPortFlowMatch_t_swigregister(ofdpaIngressPortFlowMatch_t)

class ofdpaIngressPortFlowEntry_t(_object):
    """Proxy of C ofdpaIngressPortFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaIngressPortFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaIngressPortFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaIngressPortFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaIngressPortFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaIngressPortFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaIngressPortFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["vrfAction"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_vrfAction_set
    __swig_getmethods__["vrfAction"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_vrfAction_get
    if _newclass:vrfAction = _swig_property(_OFDPA_python.ofdpaIngressPortFlowEntry_t_vrfAction_get, _OFDPA_python.ofdpaIngressPortFlowEntry_t_vrfAction_set)
    __swig_setmethods__["vrf"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_vrf_set
    __swig_getmethods__["vrf"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_vrf_get
    if _newclass:vrf = _swig_property(_OFDPA_python.ofdpaIngressPortFlowEntry_t_vrf_get, _OFDPA_python.ofdpaIngressPortFlowEntry_t_vrf_set)
    __swig_setmethods__["qosIndex"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_qosIndex_set
    __swig_getmethods__["qosIndex"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_qosIndex_get
    if _newclass:qosIndex = _swig_property(_OFDPA_python.ofdpaIngressPortFlowEntry_t_qosIndex_get, _OFDPA_python.ofdpaIngressPortFlowEntry_t_qosIndex_set)
    __swig_setmethods__["qosIndexAction"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_qosIndexAction_set
    __swig_getmethods__["qosIndexAction"] = _OFDPA_python.ofdpaIngressPortFlowEntry_t_qosIndexAction_get
    if _newclass:qosIndexAction = _swig_property(_OFDPA_python.ofdpaIngressPortFlowEntry_t_qosIndexAction_get, _OFDPA_python.ofdpaIngressPortFlowEntry_t_qosIndexAction_set)
    def __init__(self): 
        """__init__(ofdpaIngressPortFlowEntry_s self) -> ofdpaIngressPortFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaIngressPortFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaIngressPortFlowEntry_t
    __del__ = lambda self : None;
ofdpaIngressPortFlowEntry_t_swigregister = _OFDPA_python.ofdpaIngressPortFlowEntry_t_swigregister
ofdpaIngressPortFlowEntry_t_swigregister(ofdpaIngressPortFlowEntry_t)

class ofdpaInjectedOamFlowMatch_t(_object):
    """Proxy of C ofdpaInjectedOamFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaInjectedOamFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaInjectedOamFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaInjectedOamFlowMatch_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaInjectedOamFlowMatch_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowMatch_t_lmepId_get, _OFDPA_python.ofdpaInjectedOamFlowMatch_t_lmepId_set)
    def __init__(self): 
        """__init__(ofdpaInjectedOamFlowMatch_s self) -> ofdpaInjectedOamFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaInjectedOamFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaInjectedOamFlowMatch_t
    __del__ = lambda self : None;
ofdpaInjectedOamFlowMatch_t_swigregister = _OFDPA_python.ofdpaInjectedOamFlowMatch_t_swigregister
ofdpaInjectedOamFlowMatch_t_swigregister(ofdpaInjectedOamFlowMatch_t)

class ofdpaInjectedOamFlowEntry_t(_object):
    """Proxy of C ofdpaInjectedOamFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaInjectedOamFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaInjectedOamFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["tunnelIdAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_tunnelIdAction_set
    __swig_getmethods__["tunnelIdAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_tunnelIdAction_get
    if _newclass:tunnelIdAction = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_tunnelIdAction_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_tunnelIdAction_set)
    __swig_setmethods__["tunnelId"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_tunnelId_set
    __swig_getmethods__["tunnelId"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_tunnelId_get
    if _newclass:tunnelId = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_tunnelId_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_tunnelId_set)
    __swig_setmethods__["mplsL2PortAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsL2PortAction_set
    __swig_getmethods__["mplsL2PortAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsL2PortAction_get
    if _newclass:mplsL2PortAction = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsL2PortAction_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsL2PortAction_set)
    __swig_setmethods__["mplsL2Port"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsL2Port_set
    __swig_getmethods__["mplsL2Port"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsL2Port_get
    if _newclass:mplsL2Port = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsL2Port_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsL2Port_set)
    __swig_setmethods__["pushMplsGalHdr"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushMplsGalHdr_set
    __swig_getmethods__["pushMplsGalHdr"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushMplsGalHdr_get
    if _newclass:pushMplsGalHdr = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushMplsGalHdr_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushMplsGalHdr_set)
    __swig_setmethods__["mplsGalTTLAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTTLAction_set
    __swig_getmethods__["mplsGalTTLAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTTLAction_get
    if _newclass:mplsGalTTLAction = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTTLAction_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTTLAction_set)
    __swig_setmethods__["mplsGalTTL"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTTL_set
    __swig_getmethods__["mplsGalTTL"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTTL_get
    if _newclass:mplsGalTTL = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTTL_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTTL_set)
    __swig_setmethods__["mplsGalTCAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTCAction_set
    __swig_getmethods__["mplsGalTCAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTCAction_get
    if _newclass:mplsGalTCAction = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTCAction_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTCAction_set)
    __swig_setmethods__["mplsGalTC"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTC_set
    __swig_getmethods__["mplsGalTC"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTC_get
    if _newclass:mplsGalTC = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTC_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsGalTC_set)
    __swig_setmethods__["pushMplsLabelHdr"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushMplsLabelHdr_set
    __swig_getmethods__["pushMplsLabelHdr"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushMplsLabelHdr_get
    if _newclass:pushMplsLabelHdr = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushMplsLabelHdr_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushMplsLabelHdr_set)
    __swig_setmethods__["mplsLabel"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsLabel_set
    __swig_getmethods__["mplsLabel"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsLabel_get
    if _newclass:mplsLabel = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsLabel_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsLabel_set)
    __swig_setmethods__["mplsBOS"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsBOS_set
    __swig_getmethods__["mplsBOS"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsBOS_get
    if _newclass:mplsBOS = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsBOS_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsBOS_set)
    __swig_setmethods__["mplsTCAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTCAction_set
    __swig_getmethods__["mplsTCAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTCAction_get
    if _newclass:mplsTCAction = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTCAction_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTCAction_set)
    __swig_setmethods__["mplsTC"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTC_set
    __swig_getmethods__["mplsTC"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTC_get
    if _newclass:mplsTC = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTC_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTC_set)
    __swig_setmethods__["mplsTTLAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTTLAction_set
    __swig_getmethods__["mplsTTLAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTTLAction_get
    if _newclass:mplsTTLAction = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTTLAction_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTTLAction_set)
    __swig_setmethods__["mplsTTL"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTTL_set
    __swig_getmethods__["mplsTTL"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTTL_get
    if _newclass:mplsTTL = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTTL_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsTTL_set)
    __swig_setmethods__["mplsDataFirstNibbleAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsDataFirstNibbleAction_set
    __swig_getmethods__["mplsDataFirstNibbleAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsDataFirstNibbleAction_get
    if _newclass:mplsDataFirstNibbleAction = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsDataFirstNibbleAction_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsDataFirstNibbleAction_set)
    __swig_setmethods__["mplsDataFirstNibble"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsDataFirstNibble_set
    __swig_getmethods__["mplsDataFirstNibble"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsDataFirstNibble_get
    if _newclass:mplsDataFirstNibble = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsDataFirstNibble_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsDataFirstNibble_set)
    __swig_setmethods__["mplsAchChannelAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsAchChannelAction_set
    __swig_getmethods__["mplsAchChannelAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsAchChannelAction_get
    if _newclass:mplsAchChannelAction = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsAchChannelAction_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsAchChannelAction_set)
    __swig_setmethods__["mplsAchChannel"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsAchChannel_set
    __swig_getmethods__["mplsAchChannel"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsAchChannel_get
    if _newclass:mplsAchChannel = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsAchChannel_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsAchChannel_set)
    __swig_setmethods__["pushCW"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushCW_set
    __swig_getmethods__["pushCW"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushCW_get
    if _newclass:pushCW = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushCW_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_pushCW_set)
    __swig_setmethods__["mplsVlanPcpAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsVlanPcpAction_set
    __swig_getmethods__["mplsVlanPcpAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsVlanPcpAction_get
    if _newclass:mplsVlanPcpAction = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsVlanPcpAction_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsVlanPcpAction_set)
    __swig_setmethods__["mplsVlanPcp"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsVlanPcp_set
    __swig_getmethods__["mplsVlanPcp"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsVlanPcp_get
    if _newclass:mplsVlanPcp = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsVlanPcp_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_mplsVlanPcp_set)
    __swig_setmethods__["oamLmTxCountAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_oamLmTxCountAction_set
    __swig_getmethods__["oamLmTxCountAction"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_oamLmTxCountAction_get
    if _newclass:oamLmTxCountAction = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_oamLmTxCountAction_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_oamLmTxCountAction_set)
    __swig_setmethods__["groupId"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_groupId_set
    __swig_getmethods__["groupId"] = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_groupId_get
    if _newclass:groupId = _swig_property(_OFDPA_python.ofdpaInjectedOamFlowEntry_t_groupId_get, _OFDPA_python.ofdpaInjectedOamFlowEntry_t_groupId_set)
    def __init__(self): 
        """__init__(ofdpaInjectedOamFlowEntry_s self) -> ofdpaInjectedOamFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaInjectedOamFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaInjectedOamFlowEntry_t
    __del__ = lambda self : None;
ofdpaInjectedOamFlowEntry_t_swigregister = _OFDPA_python.ofdpaInjectedOamFlowEntry_t_swigregister
ofdpaInjectedOamFlowEntry_t_swigregister(ofdpaInjectedOamFlowEntry_t)

class ofdpaDscpTrustFlowMatch_t(_object):
    """Proxy of C ofdpaDscpTrustFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaDscpTrustFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaDscpTrustFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["qosIndex"] = _OFDPA_python.ofdpaDscpTrustFlowMatch_t_qosIndex_set
    __swig_getmethods__["qosIndex"] = _OFDPA_python.ofdpaDscpTrustFlowMatch_t_qosIndex_get
    if _newclass:qosIndex = _swig_property(_OFDPA_python.ofdpaDscpTrustFlowMatch_t_qosIndex_get, _OFDPA_python.ofdpaDscpTrustFlowMatch_t_qosIndex_set)
    __swig_setmethods__["dscpValue"] = _OFDPA_python.ofdpaDscpTrustFlowMatch_t_dscpValue_set
    __swig_getmethods__["dscpValue"] = _OFDPA_python.ofdpaDscpTrustFlowMatch_t_dscpValue_get
    if _newclass:dscpValue = _swig_property(_OFDPA_python.ofdpaDscpTrustFlowMatch_t_dscpValue_get, _OFDPA_python.ofdpaDscpTrustFlowMatch_t_dscpValue_set)
    __swig_setmethods__["mplsL2Port"] = _OFDPA_python.ofdpaDscpTrustFlowMatch_t_mplsL2Port_set
    __swig_getmethods__["mplsL2Port"] = _OFDPA_python.ofdpaDscpTrustFlowMatch_t_mplsL2Port_get
    if _newclass:mplsL2Port = _swig_property(_OFDPA_python.ofdpaDscpTrustFlowMatch_t_mplsL2Port_get, _OFDPA_python.ofdpaDscpTrustFlowMatch_t_mplsL2Port_set)
    __swig_setmethods__["mplsL2PortMask"] = _OFDPA_python.ofdpaDscpTrustFlowMatch_t_mplsL2PortMask_set
    __swig_getmethods__["mplsL2PortMask"] = _OFDPA_python.ofdpaDscpTrustFlowMatch_t_mplsL2PortMask_get
    if _newclass:mplsL2PortMask = _swig_property(_OFDPA_python.ofdpaDscpTrustFlowMatch_t_mplsL2PortMask_get, _OFDPA_python.ofdpaDscpTrustFlowMatch_t_mplsL2PortMask_set)
    def __init__(self): 
        """__init__(ofdpaDscpTrustFlowMatch_s self) -> ofdpaDscpTrustFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaDscpTrustFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaDscpTrustFlowMatch_t
    __del__ = lambda self : None;
ofdpaDscpTrustFlowMatch_t_swigregister = _OFDPA_python.ofdpaDscpTrustFlowMatch_t_swigregister
ofdpaDscpTrustFlowMatch_t_swigregister(ofdpaDscpTrustFlowMatch_t)

class ofdpaDscpTrustFlowEntry_t(_object):
    """Proxy of C ofdpaDscpTrustFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaDscpTrustFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaDscpTrustFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaDscpTrustFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaDscpTrustFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaDscpTrustFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaDscpTrustFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaDscpTrustFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaDscpTrustFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaDscpTrustFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaDscpTrustFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaDscpTrustFlowEntry_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaDscpTrustFlowEntry_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaDscpTrustFlowEntry_t_trafficClass_get, _OFDPA_python.ofdpaDscpTrustFlowEntry_t_trafficClass_set)
    __swig_setmethods__["color"] = _OFDPA_python.ofdpaDscpTrustFlowEntry_t_color_set
    __swig_getmethods__["color"] = _OFDPA_python.ofdpaDscpTrustFlowEntry_t_color_get
    if _newclass:color = _swig_property(_OFDPA_python.ofdpaDscpTrustFlowEntry_t_color_get, _OFDPA_python.ofdpaDscpTrustFlowEntry_t_color_set)
    def __init__(self): 
        """__init__(ofdpaDscpTrustFlowEntry_s self) -> ofdpaDscpTrustFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaDscpTrustFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaDscpTrustFlowEntry_t
    __del__ = lambda self : None;
ofdpaDscpTrustFlowEntry_t_swigregister = _OFDPA_python.ofdpaDscpTrustFlowEntry_t_swigregister
ofdpaDscpTrustFlowEntry_t_swigregister(ofdpaDscpTrustFlowEntry_t)

class ofdpaPcpTrustFlowMatch_t(_object):
    """Proxy of C ofdpaPcpTrustFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaPcpTrustFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaPcpTrustFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["qosIndex"] = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_qosIndex_set
    __swig_getmethods__["qosIndex"] = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_qosIndex_get
    if _newclass:qosIndex = _swig_property(_OFDPA_python.ofdpaPcpTrustFlowMatch_t_qosIndex_get, _OFDPA_python.ofdpaPcpTrustFlowMatch_t_qosIndex_set)
    __swig_setmethods__["pcpValue"] = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_pcpValue_set
    __swig_getmethods__["pcpValue"] = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_pcpValue_get
    if _newclass:pcpValue = _swig_property(_OFDPA_python.ofdpaPcpTrustFlowMatch_t_pcpValue_get, _OFDPA_python.ofdpaPcpTrustFlowMatch_t_pcpValue_set)
    __swig_setmethods__["dei"] = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_dei_set
    __swig_getmethods__["dei"] = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_dei_get
    if _newclass:dei = _swig_property(_OFDPA_python.ofdpaPcpTrustFlowMatch_t_dei_get, _OFDPA_python.ofdpaPcpTrustFlowMatch_t_dei_set)
    __swig_setmethods__["mplsL2Port"] = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_mplsL2Port_set
    __swig_getmethods__["mplsL2Port"] = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_mplsL2Port_get
    if _newclass:mplsL2Port = _swig_property(_OFDPA_python.ofdpaPcpTrustFlowMatch_t_mplsL2Port_get, _OFDPA_python.ofdpaPcpTrustFlowMatch_t_mplsL2Port_set)
    __swig_setmethods__["mplsL2PortMask"] = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_mplsL2PortMask_set
    __swig_getmethods__["mplsL2PortMask"] = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_mplsL2PortMask_get
    if _newclass:mplsL2PortMask = _swig_property(_OFDPA_python.ofdpaPcpTrustFlowMatch_t_mplsL2PortMask_get, _OFDPA_python.ofdpaPcpTrustFlowMatch_t_mplsL2PortMask_set)
    def __init__(self): 
        """__init__(ofdpaPcpTrustFlowMatch_s self) -> ofdpaPcpTrustFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaPcpTrustFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaPcpTrustFlowMatch_t
    __del__ = lambda self : None;
ofdpaPcpTrustFlowMatch_t_swigregister = _OFDPA_python.ofdpaPcpTrustFlowMatch_t_swigregister
ofdpaPcpTrustFlowMatch_t_swigregister(ofdpaPcpTrustFlowMatch_t)

class ofdpaPcpTrustFlowEntry_t(_object):
    """Proxy of C ofdpaPcpTrustFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaPcpTrustFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaPcpTrustFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaPcpTrustFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaPcpTrustFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaPcpTrustFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaPcpTrustFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaPcpTrustFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaPcpTrustFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaPcpTrustFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaPcpTrustFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaPcpTrustFlowEntry_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaPcpTrustFlowEntry_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaPcpTrustFlowEntry_t_trafficClass_get, _OFDPA_python.ofdpaPcpTrustFlowEntry_t_trafficClass_set)
    __swig_setmethods__["color"] = _OFDPA_python.ofdpaPcpTrustFlowEntry_t_color_set
    __swig_getmethods__["color"] = _OFDPA_python.ofdpaPcpTrustFlowEntry_t_color_get
    if _newclass:color = _swig_property(_OFDPA_python.ofdpaPcpTrustFlowEntry_t_color_get, _OFDPA_python.ofdpaPcpTrustFlowEntry_t_color_set)
    def __init__(self): 
        """__init__(ofdpaPcpTrustFlowEntry_s self) -> ofdpaPcpTrustFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaPcpTrustFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaPcpTrustFlowEntry_t
    __del__ = lambda self : None;
ofdpaPcpTrustFlowEntry_t_swigregister = _OFDPA_python.ofdpaPcpTrustFlowEntry_t_swigregister
ofdpaPcpTrustFlowEntry_t_swigregister(ofdpaPcpTrustFlowEntry_t)

class ofdpaVlanFlowMatch_t(_object):
    """Proxy of C ofdpaVlanFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaVlanFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaVlanFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["inPort"] = _OFDPA_python.ofdpaVlanFlowMatch_t_inPort_set
    __swig_getmethods__["inPort"] = _OFDPA_python.ofdpaVlanFlowMatch_t_inPort_get
    if _newclass:inPort = _swig_property(_OFDPA_python.ofdpaVlanFlowMatch_t_inPort_get, _OFDPA_python.ofdpaVlanFlowMatch_t_inPort_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaVlanFlowMatch_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaVlanFlowMatch_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaVlanFlowMatch_t_vlanId_get, _OFDPA_python.ofdpaVlanFlowMatch_t_vlanId_set)
    __swig_setmethods__["vlanIdMask"] = _OFDPA_python.ofdpaVlanFlowMatch_t_vlanIdMask_set
    __swig_getmethods__["vlanIdMask"] = _OFDPA_python.ofdpaVlanFlowMatch_t_vlanIdMask_get
    if _newclass:vlanIdMask = _swig_property(_OFDPA_python.ofdpaVlanFlowMatch_t_vlanIdMask_get, _OFDPA_python.ofdpaVlanFlowMatch_t_vlanIdMask_set)
    def __init__(self): 
        """__init__(ofdpaVlanFlowMatch_s self) -> ofdpaVlanFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaVlanFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaVlanFlowMatch_t
    __del__ = lambda self : None;
ofdpaVlanFlowMatch_t_swigregister = _OFDPA_python.ofdpaVlanFlowMatch_t_swigregister
ofdpaVlanFlowMatch_t_swigregister(ofdpaVlanFlowMatch_t)

class ofdpaVlanFlowEntry_t(_object):
    """Proxy of C ofdpaVlanFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaVlanFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaVlanFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaVlanFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaVlanFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaVlanFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaVlanFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaVlanFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaVlanFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["setVlanIdAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_setVlanIdAction_set
    __swig_getmethods__["setVlanIdAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_setVlanIdAction_get
    if _newclass:setVlanIdAction = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_setVlanIdAction_get, _OFDPA_python.ofdpaVlanFlowEntry_t_setVlanIdAction_set)
    __swig_setmethods__["newVlanId"] = _OFDPA_python.ofdpaVlanFlowEntry_t_newVlanId_set
    __swig_getmethods__["newVlanId"] = _OFDPA_python.ofdpaVlanFlowEntry_t_newVlanId_get
    if _newclass:newVlanId = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_newVlanId_get, _OFDPA_python.ofdpaVlanFlowEntry_t_newVlanId_set)
    __swig_setmethods__["popVlanAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_popVlanAction_set
    __swig_getmethods__["popVlanAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_popVlanAction_get
    if _newclass:popVlanAction = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_popVlanAction_get, _OFDPA_python.ofdpaVlanFlowEntry_t_popVlanAction_set)
    __swig_setmethods__["pushVlan2Action"] = _OFDPA_python.ofdpaVlanFlowEntry_t_pushVlan2Action_set
    __swig_getmethods__["pushVlan2Action"] = _OFDPA_python.ofdpaVlanFlowEntry_t_pushVlan2Action_get
    if _newclass:pushVlan2Action = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_pushVlan2Action_get, _OFDPA_python.ofdpaVlanFlowEntry_t_pushVlan2Action_set)
    __swig_setmethods__["newTpid2"] = _OFDPA_python.ofdpaVlanFlowEntry_t_newTpid2_set
    __swig_getmethods__["newTpid2"] = _OFDPA_python.ofdpaVlanFlowEntry_t_newTpid2_get
    if _newclass:newTpid2 = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_newTpid2_get, _OFDPA_python.ofdpaVlanFlowEntry_t_newTpid2_set)
    __swig_setmethods__["setVlanId2Action"] = _OFDPA_python.ofdpaVlanFlowEntry_t_setVlanId2Action_set
    __swig_getmethods__["setVlanId2Action"] = _OFDPA_python.ofdpaVlanFlowEntry_t_setVlanId2Action_get
    if _newclass:setVlanId2Action = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_setVlanId2Action_get, _OFDPA_python.ofdpaVlanFlowEntry_t_setVlanId2Action_set)
    __swig_setmethods__["newVlanId2"] = _OFDPA_python.ofdpaVlanFlowEntry_t_newVlanId2_set
    __swig_getmethods__["newVlanId2"] = _OFDPA_python.ofdpaVlanFlowEntry_t_newVlanId2_get
    if _newclass:newVlanId2 = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_newVlanId2_get, _OFDPA_python.ofdpaVlanFlowEntry_t_newVlanId2_set)
    __swig_setmethods__["ovidAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_ovidAction_set
    __swig_getmethods__["ovidAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_ovidAction_get
    if _newclass:ovidAction = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_ovidAction_get, _OFDPA_python.ofdpaVlanFlowEntry_t_ovidAction_set)
    __swig_setmethods__["ovid"] = _OFDPA_python.ofdpaVlanFlowEntry_t_ovid_set
    __swig_getmethods__["ovid"] = _OFDPA_python.ofdpaVlanFlowEntry_t_ovid_get
    if _newclass:ovid = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_ovid_get, _OFDPA_python.ofdpaVlanFlowEntry_t_ovid_set)
    __swig_setmethods__["vrfAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_vrfAction_set
    __swig_getmethods__["vrfAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_vrfAction_get
    if _newclass:vrfAction = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_vrfAction_get, _OFDPA_python.ofdpaVlanFlowEntry_t_vrfAction_set)
    __swig_setmethods__["vrf"] = _OFDPA_python.ofdpaVlanFlowEntry_t_vrf_set
    __swig_getmethods__["vrf"] = _OFDPA_python.ofdpaVlanFlowEntry_t_vrf_get
    if _newclass:vrf = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_vrf_get, _OFDPA_python.ofdpaVlanFlowEntry_t_vrf_set)
    __swig_setmethods__["mplsL2PortAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_mplsL2PortAction_set
    __swig_getmethods__["mplsL2PortAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_mplsL2PortAction_get
    if _newclass:mplsL2PortAction = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_mplsL2PortAction_get, _OFDPA_python.ofdpaVlanFlowEntry_t_mplsL2PortAction_set)
    __swig_setmethods__["mplsL2Port"] = _OFDPA_python.ofdpaVlanFlowEntry_t_mplsL2Port_set
    __swig_getmethods__["mplsL2Port"] = _OFDPA_python.ofdpaVlanFlowEntry_t_mplsL2Port_get
    if _newclass:mplsL2Port = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_mplsL2Port_get, _OFDPA_python.ofdpaVlanFlowEntry_t_mplsL2Port_set)
    __swig_setmethods__["tunnelIdAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_tunnelIdAction_set
    __swig_getmethods__["tunnelIdAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_tunnelIdAction_get
    if _newclass:tunnelIdAction = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_tunnelIdAction_get, _OFDPA_python.ofdpaVlanFlowEntry_t_tunnelIdAction_set)
    __swig_setmethods__["tunnelId"] = _OFDPA_python.ofdpaVlanFlowEntry_t_tunnelId_set
    __swig_getmethods__["tunnelId"] = _OFDPA_python.ofdpaVlanFlowEntry_t_tunnelId_get
    if _newclass:tunnelId = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_tunnelId_get, _OFDPA_python.ofdpaVlanFlowEntry_t_tunnelId_set)
    __swig_setmethods__["mplsTypeAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_mplsTypeAction_set
    __swig_getmethods__["mplsTypeAction"] = _OFDPA_python.ofdpaVlanFlowEntry_t_mplsTypeAction_get
    if _newclass:mplsTypeAction = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_mplsTypeAction_get, _OFDPA_python.ofdpaVlanFlowEntry_t_mplsTypeAction_set)
    __swig_setmethods__["mplsType"] = _OFDPA_python.ofdpaVlanFlowEntry_t_mplsType_set
    __swig_getmethods__["mplsType"] = _OFDPA_python.ofdpaVlanFlowEntry_t_mplsType_get
    if _newclass:mplsType = _swig_property(_OFDPA_python.ofdpaVlanFlowEntry_t_mplsType_get, _OFDPA_python.ofdpaVlanFlowEntry_t_mplsType_set)
    def __init__(self): 
        """__init__(ofdpaVlanFlowEntry_s self) -> ofdpaVlanFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaVlanFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaVlanFlowEntry_t
    __del__ = lambda self : None;
ofdpaVlanFlowEntry_t_swigregister = _OFDPA_python.ofdpaVlanFlowEntry_t_swigregister
ofdpaVlanFlowEntry_t_swigregister(ofdpaVlanFlowEntry_t)

class ofdpaVlan1FlowMatch_t(_object):
    """Proxy of C ofdpaVlan1FlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaVlan1FlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaVlan1FlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["inPort"] = _OFDPA_python.ofdpaVlan1FlowMatch_t_inPort_set
    __swig_getmethods__["inPort"] = _OFDPA_python.ofdpaVlan1FlowMatch_t_inPort_get
    if _newclass:inPort = _swig_property(_OFDPA_python.ofdpaVlan1FlowMatch_t_inPort_get, _OFDPA_python.ofdpaVlan1FlowMatch_t_inPort_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaVlan1FlowMatch_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaVlan1FlowMatch_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaVlan1FlowMatch_t_vlanId_get, _OFDPA_python.ofdpaVlan1FlowMatch_t_vlanId_set)
    __swig_setmethods__["ovid"] = _OFDPA_python.ofdpaVlan1FlowMatch_t_ovid_set
    __swig_getmethods__["ovid"] = _OFDPA_python.ofdpaVlan1FlowMatch_t_ovid_get
    if _newclass:ovid = _swig_property(_OFDPA_python.ofdpaVlan1FlowMatch_t_ovid_get, _OFDPA_python.ofdpaVlan1FlowMatch_t_ovid_set)
    def __init__(self): 
        """__init__(ofdpaVlan1FlowMatch_s self) -> ofdpaVlan1FlowMatch_t"""
        this = _OFDPA_python.new_ofdpaVlan1FlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaVlan1FlowMatch_t
    __del__ = lambda self : None;
ofdpaVlan1FlowMatch_t_swigregister = _OFDPA_python.ofdpaVlan1FlowMatch_t_swigregister
ofdpaVlan1FlowMatch_t_swigregister(ofdpaVlan1FlowMatch_t)

class ofdpaVlan1FlowEntry_t(_object):
    """Proxy of C ofdpaVlan1FlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaVlan1FlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaVlan1FlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_gotoTableId_set)
    __swig_setmethods__["setVlanIdAction"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_setVlanIdAction_set
    __swig_getmethods__["setVlanIdAction"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_setVlanIdAction_get
    if _newclass:setVlanIdAction = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_setVlanIdAction_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_setVlanIdAction_set)
    __swig_setmethods__["newVlanId"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_newVlanId_set
    __swig_getmethods__["newVlanId"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_newVlanId_get
    if _newclass:newVlanId = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_newVlanId_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_newVlanId_set)
    __swig_setmethods__["pushVlan2Action"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_pushVlan2Action_set
    __swig_getmethods__["pushVlan2Action"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_pushVlan2Action_get
    if _newclass:pushVlan2Action = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_pushVlan2Action_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_pushVlan2Action_set)
    __swig_setmethods__["newTpid2"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_newTpid2_set
    __swig_getmethods__["newTpid2"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_newTpid2_get
    if _newclass:newTpid2 = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_newTpid2_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_newTpid2_set)
    __swig_setmethods__["setVlanId2Action"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_setVlanId2Action_set
    __swig_getmethods__["setVlanId2Action"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_setVlanId2Action_get
    if _newclass:setVlanId2Action = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_setVlanId2Action_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_setVlanId2Action_set)
    __swig_setmethods__["newVlanId2"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_newVlanId2_set
    __swig_getmethods__["newVlanId2"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_newVlanId2_get
    if _newclass:newVlanId2 = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_newVlanId2_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_newVlanId2_set)
    __swig_setmethods__["vrfAction"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_vrfAction_set
    __swig_getmethods__["vrfAction"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_vrfAction_get
    if _newclass:vrfAction = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_vrfAction_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_vrfAction_set)
    __swig_setmethods__["vrf"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_vrf_set
    __swig_getmethods__["vrf"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_vrf_get
    if _newclass:vrf = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_vrf_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_vrf_set)
    __swig_setmethods__["mplsL2PortAction"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsL2PortAction_set
    __swig_getmethods__["mplsL2PortAction"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsL2PortAction_get
    if _newclass:mplsL2PortAction = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_mplsL2PortAction_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsL2PortAction_set)
    __swig_setmethods__["mplsL2Port"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsL2Port_set
    __swig_getmethods__["mplsL2Port"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsL2Port_get
    if _newclass:mplsL2Port = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_mplsL2Port_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsL2Port_set)
    __swig_setmethods__["tunnelIdAction"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_tunnelIdAction_set
    __swig_getmethods__["tunnelIdAction"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_tunnelIdAction_get
    if _newclass:tunnelIdAction = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_tunnelIdAction_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_tunnelIdAction_set)
    __swig_setmethods__["tunnelId"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_tunnelId_set
    __swig_getmethods__["tunnelId"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_tunnelId_get
    if _newclass:tunnelId = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_tunnelId_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_tunnelId_set)
    __swig_setmethods__["mplsTypeAction"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsTypeAction_set
    __swig_getmethods__["mplsTypeAction"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsTypeAction_get
    if _newclass:mplsTypeAction = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_mplsTypeAction_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsTypeAction_set)
    __swig_setmethods__["mplsType"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsType_set
    __swig_getmethods__["mplsType"] = _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsType_get
    if _newclass:mplsType = _swig_property(_OFDPA_python.ofdpaVlan1FlowEntry_t_mplsType_get, _OFDPA_python.ofdpaVlan1FlowEntry_t_mplsType_set)
    def __init__(self): 
        """__init__(ofdpaVlan1FlowEntry_s self) -> ofdpaVlan1FlowEntry_t"""
        this = _OFDPA_python.new_ofdpaVlan1FlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaVlan1FlowEntry_t
    __del__ = lambda self : None;
ofdpaVlan1FlowEntry_t_swigregister = _OFDPA_python.ofdpaVlan1FlowEntry_t_swigregister
ofdpaVlan1FlowEntry_t_swigregister(ofdpaVlan1FlowEntry_t)

class ofdpaMpFlowMatch_t(_object):
    """Proxy of C ofdpaMpFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMpFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMpFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaMpFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaMpFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_etherType_get, _OFDPA_python.ofdpaMpFlowMatch_t_etherType_set)
    __swig_setmethods__["etherTypeMask"] = _OFDPA_python.ofdpaMpFlowMatch_t_etherTypeMask_set
    __swig_getmethods__["etherTypeMask"] = _OFDPA_python.ofdpaMpFlowMatch_t_etherTypeMask_get
    if _newclass:etherTypeMask = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_etherTypeMask_get, _OFDPA_python.ofdpaMpFlowMatch_t_etherTypeMask_set)
    __swig_setmethods__["oamY1731Mdl"] = _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731Mdl_set
    __swig_getmethods__["oamY1731Mdl"] = _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731Mdl_get
    if _newclass:oamY1731Mdl = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_oamY1731Mdl_get, _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731Mdl_set)
    __swig_setmethods__["oamY1731MdlMask"] = _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731MdlMask_set
    __swig_getmethods__["oamY1731MdlMask"] = _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731MdlMask_get
    if _newclass:oamY1731MdlMask = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_oamY1731MdlMask_get, _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731MdlMask_set)
    __swig_setmethods__["oamY1731Opcode"] = _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731Opcode_set
    __swig_getmethods__["oamY1731Opcode"] = _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731Opcode_get
    if _newclass:oamY1731Opcode = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_oamY1731Opcode_get, _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731Opcode_set)
    __swig_setmethods__["oamY1731OpcodeMask"] = _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731OpcodeMask_set
    __swig_getmethods__["oamY1731OpcodeMask"] = _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731OpcodeMask_get
    if _newclass:oamY1731OpcodeMask = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_oamY1731OpcodeMask_get, _OFDPA_python.ofdpaMpFlowMatch_t_oamY1731OpcodeMask_set)
    __swig_setmethods__["inPort"] = _OFDPA_python.ofdpaMpFlowMatch_t_inPort_set
    __swig_getmethods__["inPort"] = _OFDPA_python.ofdpaMpFlowMatch_t_inPort_get
    if _newclass:inPort = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_inPort_get, _OFDPA_python.ofdpaMpFlowMatch_t_inPort_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaMpFlowMatch_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaMpFlowMatch_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_vlanId_get, _OFDPA_python.ofdpaMpFlowMatch_t_vlanId_set)
    __swig_setmethods__["vlanIdMask"] = _OFDPA_python.ofdpaMpFlowMatch_t_vlanIdMask_set
    __swig_getmethods__["vlanIdMask"] = _OFDPA_python.ofdpaMpFlowMatch_t_vlanIdMask_get
    if _newclass:vlanIdMask = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_vlanIdMask_get, _OFDPA_python.ofdpaMpFlowMatch_t_vlanIdMask_set)
    __swig_setmethods__["destMac"] = _OFDPA_python.ofdpaMpFlowMatch_t_destMac_set
    __swig_getmethods__["destMac"] = _OFDPA_python.ofdpaMpFlowMatch_t_destMac_get
    if _newclass:destMac = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_destMac_get, _OFDPA_python.ofdpaMpFlowMatch_t_destMac_set)
    __swig_setmethods__["destMacMask"] = _OFDPA_python.ofdpaMpFlowMatch_t_destMacMask_set
    __swig_getmethods__["destMacMask"] = _OFDPA_python.ofdpaMpFlowMatch_t_destMacMask_get
    if _newclass:destMacMask = _swig_property(_OFDPA_python.ofdpaMpFlowMatch_t_destMacMask_get, _OFDPA_python.ofdpaMpFlowMatch_t_destMacMask_set)
    def __init__(self): 
        """__init__(ofdpaMpFlowMatch_s self) -> ofdpaMpFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaMpFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMpFlowMatch_t
    __del__ = lambda self : None;
ofdpaMpFlowMatch_t_swigregister = _OFDPA_python.ofdpaMpFlowMatch_t_swigregister
ofdpaMpFlowMatch_t_swigregister(ofdpaMpFlowMatch_t)

class ofdpaMpFlowEntry_t(_object):
    """Proxy of C ofdpaMpFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMpFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMpFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaMpFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaMpFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaMpFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaMpFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaMpFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaMpFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaMpFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaMpFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["clearAction"] = _OFDPA_python.ofdpaMpFlowEntry_t_clearAction_set
    __swig_getmethods__["clearAction"] = _OFDPA_python.ofdpaMpFlowEntry_t_clearAction_get
    if _newclass:clearAction = _swig_property(_OFDPA_python.ofdpaMpFlowEntry_t_clearAction_get, _OFDPA_python.ofdpaMpFlowEntry_t_clearAction_set)
    __swig_setmethods__["lmepIdAction"] = _OFDPA_python.ofdpaMpFlowEntry_t_lmepIdAction_set
    __swig_getmethods__["lmepIdAction"] = _OFDPA_python.ofdpaMpFlowEntry_t_lmepIdAction_get
    if _newclass:lmepIdAction = _swig_property(_OFDPA_python.ofdpaMpFlowEntry_t_lmepIdAction_get, _OFDPA_python.ofdpaMpFlowEntry_t_lmepIdAction_set)
    __swig_setmethods__["oamLmTxCountAction"] = _OFDPA_python.ofdpaMpFlowEntry_t_oamLmTxCountAction_set
    __swig_getmethods__["oamLmTxCountAction"] = _OFDPA_python.ofdpaMpFlowEntry_t_oamLmTxCountAction_get
    if _newclass:oamLmTxCountAction = _swig_property(_OFDPA_python.ofdpaMpFlowEntry_t_oamLmTxCountAction_get, _OFDPA_python.ofdpaMpFlowEntry_t_oamLmTxCountAction_set)
    __swig_setmethods__["checkDropStatusAction"] = _OFDPA_python.ofdpaMpFlowEntry_t_checkDropStatusAction_set
    __swig_getmethods__["checkDropStatusAction"] = _OFDPA_python.ofdpaMpFlowEntry_t_checkDropStatusAction_get
    if _newclass:checkDropStatusAction = _swig_property(_OFDPA_python.ofdpaMpFlowEntry_t_checkDropStatusAction_get, _OFDPA_python.ofdpaMpFlowEntry_t_checkDropStatusAction_set)
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaMpFlowEntry_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaMpFlowEntry_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaMpFlowEntry_t_lmepId_get, _OFDPA_python.ofdpaMpFlowEntry_t_lmepId_set)
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaMpFlowEntry_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaMpFlowEntry_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaMpFlowEntry_t_outputPort_get, _OFDPA_python.ofdpaMpFlowEntry_t_outputPort_set)
    def __init__(self): 
        """__init__(ofdpaMpFlowEntry_s self) -> ofdpaMpFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaMpFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMpFlowEntry_t
    __del__ = lambda self : None;
ofdpaMpFlowEntry_t_swigregister = _OFDPA_python.ofdpaMpFlowEntry_t_swigregister
ofdpaMpFlowEntry_t_swigregister(ofdpaMpFlowEntry_t)

class ofdpaMplsL2PortFlowMatch_t(_object):
    """Proxy of C ofdpaMplsL2PortFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMplsL2PortFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMplsL2PortFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mplsL2Port"] = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_mplsL2Port_set
    __swig_getmethods__["mplsL2Port"] = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_mplsL2Port_get
    if _newclass:mplsL2Port = _swig_property(_OFDPA_python.ofdpaMplsL2PortFlowMatch_t_mplsL2Port_get, _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_mplsL2Port_set)
    __swig_setmethods__["mplsL2PortMask"] = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_mplsL2PortMask_set
    __swig_getmethods__["mplsL2PortMask"] = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_mplsL2PortMask_get
    if _newclass:mplsL2PortMask = _swig_property(_OFDPA_python.ofdpaMplsL2PortFlowMatch_t_mplsL2PortMask_get, _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_mplsL2PortMask_set)
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaMplsL2PortFlowMatch_t_etherType_get, _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_etherType_set)
    __swig_setmethods__["etherTypeMask"] = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_etherTypeMask_set
    __swig_getmethods__["etherTypeMask"] = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_etherTypeMask_get
    if _newclass:etherTypeMask = _swig_property(_OFDPA_python.ofdpaMplsL2PortFlowMatch_t_etherTypeMask_get, _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_etherTypeMask_set)
    __swig_setmethods__["tunnelId"] = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_tunnelId_set
    __swig_getmethods__["tunnelId"] = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_tunnelId_get
    if _newclass:tunnelId = _swig_property(_OFDPA_python.ofdpaMplsL2PortFlowMatch_t_tunnelId_get, _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_tunnelId_set)
    def __init__(self): 
        """__init__(ofdpaMplsL2PortFlowMatch_s self) -> ofdpaMplsL2PortFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaMplsL2PortFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMplsL2PortFlowMatch_t
    __del__ = lambda self : None;
ofdpaMplsL2PortFlowMatch_t_swigregister = _OFDPA_python.ofdpaMplsL2PortFlowMatch_t_swigregister
ofdpaMplsL2PortFlowMatch_t_swigregister(ofdpaMplsL2PortFlowMatch_t)

class ofdpaMplsL2PortFlowEntry_t(_object):
    """Proxy of C ofdapMplsL2PortFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMplsL2PortFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMplsL2PortFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaMplsL2PortFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaMplsL2PortFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["qosIndex"] = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_qosIndex_set
    __swig_getmethods__["qosIndex"] = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_qosIndex_get
    if _newclass:qosIndex = _swig_property(_OFDPA_python.ofdpaMplsL2PortFlowEntry_t_qosIndex_get, _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_qosIndex_set)
    __swig_setmethods__["qosIndexAction"] = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_qosIndexAction_set
    __swig_getmethods__["qosIndexAction"] = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_qosIndexAction_get
    if _newclass:qosIndexAction = _swig_property(_OFDPA_python.ofdpaMplsL2PortFlowEntry_t_qosIndexAction_get, _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_qosIndexAction_set)
    __swig_setmethods__["groupId"] = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_groupId_set
    __swig_getmethods__["groupId"] = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_groupId_get
    if _newclass:groupId = _swig_property(_OFDPA_python.ofdpaMplsL2PortFlowEntry_t_groupId_get, _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_groupId_set)
    def __init__(self): 
        """__init__(ofdapMplsL2PortFlowEntry_s self) -> ofdpaMplsL2PortFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaMplsL2PortFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMplsL2PortFlowEntry_t
    __del__ = lambda self : None;
ofdpaMplsL2PortFlowEntry_t_swigregister = _OFDPA_python.ofdpaMplsL2PortFlowEntry_t_swigregister
ofdpaMplsL2PortFlowEntry_t_swigregister(ofdpaMplsL2PortFlowEntry_t)

class ofdpaTerminationMacFlowMatch_t(_object):
    """Proxy of C ofdpaTerminationMacFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTerminationMacFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTerminationMacFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["inPort"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_inPort_set
    __swig_getmethods__["inPort"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_inPort_get
    if _newclass:inPort = _swig_property(_OFDPA_python.ofdpaTerminationMacFlowMatch_t_inPort_get, _OFDPA_python.ofdpaTerminationMacFlowMatch_t_inPort_set)
    __swig_setmethods__["inPortMask"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_inPortMask_set
    __swig_getmethods__["inPortMask"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_inPortMask_get
    if _newclass:inPortMask = _swig_property(_OFDPA_python.ofdpaTerminationMacFlowMatch_t_inPortMask_get, _OFDPA_python.ofdpaTerminationMacFlowMatch_t_inPortMask_set)
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaTerminationMacFlowMatch_t_etherType_get, _OFDPA_python.ofdpaTerminationMacFlowMatch_t_etherType_set)
    __swig_setmethods__["destMac"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_destMac_set
    __swig_getmethods__["destMac"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_destMac_get
    if _newclass:destMac = _swig_property(_OFDPA_python.ofdpaTerminationMacFlowMatch_t_destMac_get, _OFDPA_python.ofdpaTerminationMacFlowMatch_t_destMac_set)
    __swig_setmethods__["destMacMask"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_destMacMask_set
    __swig_getmethods__["destMacMask"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_destMacMask_get
    if _newclass:destMacMask = _swig_property(_OFDPA_python.ofdpaTerminationMacFlowMatch_t_destMacMask_get, _OFDPA_python.ofdpaTerminationMacFlowMatch_t_destMacMask_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaTerminationMacFlowMatch_t_vlanId_get, _OFDPA_python.ofdpaTerminationMacFlowMatch_t_vlanId_set)
    __swig_setmethods__["vlanIdMask"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_vlanIdMask_set
    __swig_getmethods__["vlanIdMask"] = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_vlanIdMask_get
    if _newclass:vlanIdMask = _swig_property(_OFDPA_python.ofdpaTerminationMacFlowMatch_t_vlanIdMask_get, _OFDPA_python.ofdpaTerminationMacFlowMatch_t_vlanIdMask_set)
    def __init__(self): 
        """__init__(ofdpaTerminationMacFlowMatch_s self) -> ofdpaTerminationMacFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaTerminationMacFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTerminationMacFlowMatch_t
    __del__ = lambda self : None;
ofdpaTerminationMacFlowMatch_t_swigregister = _OFDPA_python.ofdpaTerminationMacFlowMatch_t_swigregister
ofdpaTerminationMacFlowMatch_t_swigregister(ofdpaTerminationMacFlowMatch_t)

class ofdpaTerminationMacFlowEntry_t(_object):
    """Proxy of C ofdpaTerminationMacFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTerminationMacFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTerminationMacFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaTerminationMacFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaTerminationMacFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaTerminationMacFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaTerminationMacFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaTerminationMacFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaTerminationMacFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaTerminationMacFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaTerminationMacFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaTerminationMacFlowEntry_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaTerminationMacFlowEntry_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaTerminationMacFlowEntry_t_outputPort_get, _OFDPA_python.ofdpaTerminationMacFlowEntry_t_outputPort_set)
    def __init__(self): 
        """__init__(ofdpaTerminationMacFlowEntry_s self) -> ofdpaTerminationMacFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaTerminationMacFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTerminationMacFlowEntry_t
    __del__ = lambda self : None;
ofdpaTerminationMacFlowEntry_t_swigregister = _OFDPA_python.ofdpaTerminationMacFlowEntry_t_swigregister
ofdpaTerminationMacFlowEntry_t_swigregister(ofdpaTerminationMacFlowEntry_t)

class ofdpaMplsFlowMatch_t(_object):
    """Proxy of C ofdpaMplsFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMplsFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMplsFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaMplsFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaMplsFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_etherType_get, _OFDPA_python.ofdpaMplsFlowMatch_t_etherType_set)
    __swig_setmethods__["mplsBos"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsBos_set
    __swig_getmethods__["mplsBos"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsBos_get
    if _newclass:mplsBos = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_mplsBos_get, _OFDPA_python.ofdpaMplsFlowMatch_t_mplsBos_set)
    __swig_setmethods__["mplsLabel"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsLabel_set
    __swig_getmethods__["mplsLabel"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsLabel_get
    if _newclass:mplsLabel = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_mplsLabel_get, _OFDPA_python.ofdpaMplsFlowMatch_t_mplsLabel_set)
    __swig_setmethods__["inPort"] = _OFDPA_python.ofdpaMplsFlowMatch_t_inPort_set
    __swig_getmethods__["inPort"] = _OFDPA_python.ofdpaMplsFlowMatch_t_inPort_get
    if _newclass:inPort = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_inPort_get, _OFDPA_python.ofdpaMplsFlowMatch_t_inPort_set)
    __swig_setmethods__["inPortMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_inPortMask_set
    __swig_getmethods__["inPortMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_inPortMask_get
    if _newclass:inPortMask = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_inPortMask_get, _OFDPA_python.ofdpaMplsFlowMatch_t_inPortMask_set)
    __swig_setmethods__["mplsTtl"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsTtl_set
    __swig_getmethods__["mplsTtl"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsTtl_get
    if _newclass:mplsTtl = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_mplsTtl_get, _OFDPA_python.ofdpaMplsFlowMatch_t_mplsTtl_set)
    __swig_setmethods__["mplsTtlMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsTtlMask_set
    __swig_getmethods__["mplsTtlMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsTtlMask_get
    if _newclass:mplsTtlMask = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_mplsTtlMask_get, _OFDPA_python.ofdpaMplsFlowMatch_t_mplsTtlMask_set)
    __swig_setmethods__["mplsDataFirstNibble"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsDataFirstNibble_set
    __swig_getmethods__["mplsDataFirstNibble"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsDataFirstNibble_get
    if _newclass:mplsDataFirstNibble = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_mplsDataFirstNibble_get, _OFDPA_python.ofdpaMplsFlowMatch_t_mplsDataFirstNibble_set)
    __swig_setmethods__["mplsDataFirstNibbleMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsDataFirstNibbleMask_set
    __swig_getmethods__["mplsDataFirstNibbleMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsDataFirstNibbleMask_get
    if _newclass:mplsDataFirstNibbleMask = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_mplsDataFirstNibbleMask_get, _OFDPA_python.ofdpaMplsFlowMatch_t_mplsDataFirstNibbleMask_set)
    __swig_setmethods__["mplsAchChannel"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsAchChannel_set
    __swig_getmethods__["mplsAchChannel"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsAchChannel_get
    if _newclass:mplsAchChannel = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_mplsAchChannel_get, _OFDPA_python.ofdpaMplsFlowMatch_t_mplsAchChannel_set)
    __swig_setmethods__["mplsAchChannelMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsAchChannelMask_set
    __swig_getmethods__["mplsAchChannelMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_mplsAchChannelMask_get
    if _newclass:mplsAchChannelMask = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_mplsAchChannelMask_get, _OFDPA_python.ofdpaMplsFlowMatch_t_mplsAchChannelMask_set)
    __swig_setmethods__["nextLabelIsGal"] = _OFDPA_python.ofdpaMplsFlowMatch_t_nextLabelIsGal_set
    __swig_getmethods__["nextLabelIsGal"] = _OFDPA_python.ofdpaMplsFlowMatch_t_nextLabelIsGal_get
    if _newclass:nextLabelIsGal = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_nextLabelIsGal_get, _OFDPA_python.ofdpaMplsFlowMatch_t_nextLabelIsGal_set)
    __swig_setmethods__["nextLabelIsGalMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_nextLabelIsGalMask_set
    __swig_getmethods__["nextLabelIsGalMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_nextLabelIsGalMask_get
    if _newclass:nextLabelIsGalMask = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_nextLabelIsGalMask_get, _OFDPA_python.ofdpaMplsFlowMatch_t_nextLabelIsGalMask_set)
    __swig_setmethods__["destIp4"] = _OFDPA_python.ofdpaMplsFlowMatch_t_destIp4_set
    __swig_getmethods__["destIp4"] = _OFDPA_python.ofdpaMplsFlowMatch_t_destIp4_get
    if _newclass:destIp4 = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_destIp4_get, _OFDPA_python.ofdpaMplsFlowMatch_t_destIp4_set)
    __swig_setmethods__["destIp4Mask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_destIp4Mask_set
    __swig_getmethods__["destIp4Mask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_destIp4Mask_get
    if _newclass:destIp4Mask = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_destIp4Mask_get, _OFDPA_python.ofdpaMplsFlowMatch_t_destIp4Mask_set)
    __swig_setmethods__["destIp6"] = _OFDPA_python.ofdpaMplsFlowMatch_t_destIp6_set
    __swig_getmethods__["destIp6"] = _OFDPA_python.ofdpaMplsFlowMatch_t_destIp6_get
    if _newclass:destIp6 = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_destIp6_get, _OFDPA_python.ofdpaMplsFlowMatch_t_destIp6_set)
    __swig_setmethods__["destIp6Mask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_destIp6Mask_set
    __swig_getmethods__["destIp6Mask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_destIp6Mask_get
    if _newclass:destIp6Mask = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_destIp6Mask_get, _OFDPA_python.ofdpaMplsFlowMatch_t_destIp6Mask_set)
    __swig_setmethods__["ipProto"] = _OFDPA_python.ofdpaMplsFlowMatch_t_ipProto_set
    __swig_getmethods__["ipProto"] = _OFDPA_python.ofdpaMplsFlowMatch_t_ipProto_get
    if _newclass:ipProto = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_ipProto_get, _OFDPA_python.ofdpaMplsFlowMatch_t_ipProto_set)
    __swig_setmethods__["ipProtoMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_ipProtoMask_set
    __swig_getmethods__["ipProtoMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_ipProtoMask_get
    if _newclass:ipProtoMask = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_ipProtoMask_get, _OFDPA_python.ofdpaMplsFlowMatch_t_ipProtoMask_set)
    __swig_setmethods__["udpSrcPort"] = _OFDPA_python.ofdpaMplsFlowMatch_t_udpSrcPort_set
    __swig_getmethods__["udpSrcPort"] = _OFDPA_python.ofdpaMplsFlowMatch_t_udpSrcPort_get
    if _newclass:udpSrcPort = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_udpSrcPort_get, _OFDPA_python.ofdpaMplsFlowMatch_t_udpSrcPort_set)
    __swig_setmethods__["udpSrcPortMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_udpSrcPortMask_set
    __swig_getmethods__["udpSrcPortMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_udpSrcPortMask_get
    if _newclass:udpSrcPortMask = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_udpSrcPortMask_get, _OFDPA_python.ofdpaMplsFlowMatch_t_udpSrcPortMask_set)
    __swig_setmethods__["udpDstPort"] = _OFDPA_python.ofdpaMplsFlowMatch_t_udpDstPort_set
    __swig_getmethods__["udpDstPort"] = _OFDPA_python.ofdpaMplsFlowMatch_t_udpDstPort_get
    if _newclass:udpDstPort = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_udpDstPort_get, _OFDPA_python.ofdpaMplsFlowMatch_t_udpDstPort_set)
    __swig_setmethods__["udpDstPortMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_udpDstPortMask_set
    __swig_getmethods__["udpDstPortMask"] = _OFDPA_python.ofdpaMplsFlowMatch_t_udpDstPortMask_get
    if _newclass:udpDstPortMask = _swig_property(_OFDPA_python.ofdpaMplsFlowMatch_t_udpDstPortMask_get, _OFDPA_python.ofdpaMplsFlowMatch_t_udpDstPortMask_set)
    def __init__(self): 
        """__init__(ofdpaMplsFlowMatch_s self) -> ofdpaMplsFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaMplsFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMplsFlowMatch_t
    __del__ = lambda self : None;
ofdpaMplsFlowMatch_t_swigregister = _OFDPA_python.ofdpaMplsFlowMatch_t_swigregister
ofdpaMplsFlowMatch_t_swigregister(ofdpaMplsFlowMatch_t)

class ofdpaMplsFlowEntry_t(_object):
    """Proxy of C ofdpaMplsFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMplsFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMplsFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaMplsFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaMplsFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaMplsFlowEntry_t_match_criteria_set)
    __swig_setmethods__["clearAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_clearAction_set
    __swig_getmethods__["clearAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_clearAction_get
    if _newclass:clearAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_clearAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_clearAction_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaMplsFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaMplsFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaMplsFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["popLabelAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_popLabelAction_set
    __swig_getmethods__["popLabelAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_popLabelAction_get
    if _newclass:popLabelAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_popLabelAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_popLabelAction_set)
    __swig_setmethods__["newEtherType"] = _OFDPA_python.ofdpaMplsFlowEntry_t_newEtherType_set
    __swig_getmethods__["newEtherType"] = _OFDPA_python.ofdpaMplsFlowEntry_t_newEtherType_get
    if _newclass:newEtherType = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_newEtherType_get, _OFDPA_python.ofdpaMplsFlowEntry_t_newEtherType_set)
    __swig_setmethods__["decrementTtlAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_decrementTtlAction_set
    __swig_getmethods__["decrementTtlAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_decrementTtlAction_get
    if _newclass:decrementTtlAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_decrementTtlAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_decrementTtlAction_set)
    __swig_setmethods__["copyTtlInAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_copyTtlInAction_set
    __swig_getmethods__["copyTtlInAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_copyTtlInAction_get
    if _newclass:copyTtlInAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_copyTtlInAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_copyTtlInAction_set)
    __swig_setmethods__["copyTcInAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_copyTcInAction_set
    __swig_getmethods__["copyTcInAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_copyTcInAction_get
    if _newclass:copyTcInAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_copyTcInAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_copyTcInAction_set)
    __swig_setmethods__["vrfAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_vrfAction_set
    __swig_getmethods__["vrfAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_vrfAction_get
    if _newclass:vrfAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_vrfAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_vrfAction_set)
    __swig_setmethods__["vrf"] = _OFDPA_python.ofdpaMplsFlowEntry_t_vrf_set
    __swig_getmethods__["vrf"] = _OFDPA_python.ofdpaMplsFlowEntry_t_vrf_get
    if _newclass:vrf = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_vrf_get, _OFDPA_python.ofdpaMplsFlowEntry_t_vrf_set)
    __swig_setmethods__["mplsL2PortAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_mplsL2PortAction_set
    __swig_getmethods__["mplsL2PortAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_mplsL2PortAction_get
    if _newclass:mplsL2PortAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_mplsL2PortAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_mplsL2PortAction_set)
    __swig_setmethods__["mplsL2Port"] = _OFDPA_python.ofdpaMplsFlowEntry_t_mplsL2Port_set
    __swig_getmethods__["mplsL2Port"] = _OFDPA_python.ofdpaMplsFlowEntry_t_mplsL2Port_get
    if _newclass:mplsL2Port = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_mplsL2Port_get, _OFDPA_python.ofdpaMplsFlowEntry_t_mplsL2Port_set)
    __swig_setmethods__["tunnelIdAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_tunnelIdAction_set
    __swig_getmethods__["tunnelIdAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_tunnelIdAction_get
    if _newclass:tunnelIdAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_tunnelIdAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_tunnelIdAction_set)
    __swig_setmethods__["tunnelId"] = _OFDPA_python.ofdpaMplsFlowEntry_t_tunnelId_set
    __swig_getmethods__["tunnelId"] = _OFDPA_python.ofdpaMplsFlowEntry_t_tunnelId_get
    if _newclass:tunnelId = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_tunnelId_get, _OFDPA_python.ofdpaMplsFlowEntry_t_tunnelId_set)
    __swig_setmethods__["qosIndexAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_qosIndexAction_set
    __swig_getmethods__["qosIndexAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_qosIndexAction_get
    if _newclass:qosIndexAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_qosIndexAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_qosIndexAction_set)
    __swig_setmethods__["qosIndex"] = _OFDPA_python.ofdpaMplsFlowEntry_t_qosIndex_set
    __swig_getmethods__["qosIndex"] = _OFDPA_python.ofdpaMplsFlowEntry_t_qosIndex_get
    if _newclass:qosIndex = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_qosIndex_get, _OFDPA_python.ofdpaMplsFlowEntry_t_qosIndex_set)
    __swig_setmethods__["trafficClassAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_trafficClassAction_set
    __swig_getmethods__["trafficClassAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_trafficClassAction_get
    if _newclass:trafficClassAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_trafficClassAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_trafficClassAction_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaMplsFlowEntry_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaMplsFlowEntry_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_trafficClass_get, _OFDPA_python.ofdpaMplsFlowEntry_t_trafficClass_set)
    __swig_setmethods__["vlanIdAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_vlanIdAction_set
    __swig_getmethods__["vlanIdAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_vlanIdAction_get
    if _newclass:vlanIdAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_vlanIdAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_vlanIdAction_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaMplsFlowEntry_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaMplsFlowEntry_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_vlanId_get, _OFDPA_python.ofdpaMplsFlowEntry_t_vlanId_set)
    __swig_setmethods__["popCwAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_popCwAction_set
    __swig_getmethods__["popCwAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_popCwAction_get
    if _newclass:popCwAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_popCwAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_popCwAction_set)
    __swig_setmethods__["popVlanAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_popVlanAction_set
    __swig_getmethods__["popVlanAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_popVlanAction_get
    if _newclass:popVlanAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_popVlanAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_popVlanAction_set)
    __swig_setmethods__["popL2HeaderAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_popL2HeaderAction_set
    __swig_getmethods__["popL2HeaderAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_popL2HeaderAction_get
    if _newclass:popL2HeaderAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_popL2HeaderAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_popL2HeaderAction_set)
    __swig_setmethods__["lmepIdAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_lmepIdAction_set
    __swig_getmethods__["lmepIdAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_lmepIdAction_get
    if _newclass:lmepIdAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_lmepIdAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_lmepIdAction_set)
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaMplsFlowEntry_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaMplsFlowEntry_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_lmepId_get, _OFDPA_python.ofdpaMplsFlowEntry_t_lmepId_set)
    __swig_setmethods__["oamLmRxCountAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_oamLmRxCountAction_set
    __swig_getmethods__["oamLmRxCountAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_oamLmRxCountAction_get
    if _newclass:oamLmRxCountAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_oamLmRxCountAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_oamLmRxCountAction_set)
    __swig_setmethods__["checkDropStatusAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_checkDropStatusAction_set
    __swig_getmethods__["checkDropStatusAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_checkDropStatusAction_get
    if _newclass:checkDropStatusAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_checkDropStatusAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_checkDropStatusAction_set)
    __swig_setmethods__["checkDropStatus2Action"] = _OFDPA_python.ofdpaMplsFlowEntry_t_checkDropStatus2Action_set
    __swig_getmethods__["checkDropStatus2Action"] = _OFDPA_python.ofdpaMplsFlowEntry_t_checkDropStatus2Action_get
    if _newclass:checkDropStatus2Action = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_checkDropStatus2Action_get, _OFDPA_python.ofdpaMplsFlowEntry_t_checkDropStatus2Action_set)
    __swig_setmethods__["dropIndex"] = _OFDPA_python.ofdpaMplsFlowEntry_t_dropIndex_set
    __swig_getmethods__["dropIndex"] = _OFDPA_python.ofdpaMplsFlowEntry_t_dropIndex_get
    if _newclass:dropIndex = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_dropIndex_get, _OFDPA_python.ofdpaMplsFlowEntry_t_dropIndex_set)
    __swig_setmethods__["dropType"] = _OFDPA_python.ofdpaMplsFlowEntry_t_dropType_set
    __swig_getmethods__["dropType"] = _OFDPA_python.ofdpaMplsFlowEntry_t_dropType_get
    if _newclass:dropType = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_dropType_get, _OFDPA_python.ofdpaMplsFlowEntry_t_dropType_set)
    __swig_setmethods__["protectionIdAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_protectionIdAction_set
    __swig_getmethods__["protectionIdAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_protectionIdAction_get
    if _newclass:protectionIdAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_protectionIdAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_protectionIdAction_set)
    __swig_setmethods__["protectionId"] = _OFDPA_python.ofdpaMplsFlowEntry_t_protectionId_set
    __swig_getmethods__["protectionId"] = _OFDPA_python.ofdpaMplsFlowEntry_t_protectionId_get
    if _newclass:protectionId = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_protectionId_get, _OFDPA_python.ofdpaMplsFlowEntry_t_protectionId_set)
    __swig_setmethods__["mplsTypeAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_mplsTypeAction_set
    __swig_getmethods__["mplsTypeAction"] = _OFDPA_python.ofdpaMplsFlowEntry_t_mplsTypeAction_get
    if _newclass:mplsTypeAction = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_mplsTypeAction_get, _OFDPA_python.ofdpaMplsFlowEntry_t_mplsTypeAction_set)
    __swig_setmethods__["mplsType"] = _OFDPA_python.ofdpaMplsFlowEntry_t_mplsType_set
    __swig_getmethods__["mplsType"] = _OFDPA_python.ofdpaMplsFlowEntry_t_mplsType_get
    if _newclass:mplsType = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_mplsType_get, _OFDPA_python.ofdpaMplsFlowEntry_t_mplsType_set)
    __swig_setmethods__["groupID"] = _OFDPA_python.ofdpaMplsFlowEntry_t_groupID_set
    __swig_getmethods__["groupID"] = _OFDPA_python.ofdpaMplsFlowEntry_t_groupID_get
    if _newclass:groupID = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_groupID_get, _OFDPA_python.ofdpaMplsFlowEntry_t_groupID_set)
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaMplsFlowEntry_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaMplsFlowEntry_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaMplsFlowEntry_t_outputPort_get, _OFDPA_python.ofdpaMplsFlowEntry_t_outputPort_set)
    def __init__(self): 
        """__init__(ofdpaMplsFlowEntry_s self) -> ofdpaMplsFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaMplsFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMplsFlowEntry_t
    __del__ = lambda self : None;
ofdpaMplsFlowEntry_t_swigregister = _OFDPA_python.ofdpaMplsFlowEntry_t_swigregister
ofdpaMplsFlowEntry_t_swigregister(ofdpaMplsFlowEntry_t)

class ofdpaMplsMpFlowMatch_t(_object):
    """Proxy of C ofdpaMplsMpFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMplsMpFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMplsMpFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaMplsMpFlowMatch_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaMplsMpFlowMatch_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaMplsMpFlowMatch_t_lmepId_get, _OFDPA_python.ofdpaMplsMpFlowMatch_t_lmepId_set)
    __swig_setmethods__["oamY1731Opcode"] = _OFDPA_python.ofdpaMplsMpFlowMatch_t_oamY1731Opcode_set
    __swig_getmethods__["oamY1731Opcode"] = _OFDPA_python.ofdpaMplsMpFlowMatch_t_oamY1731Opcode_get
    if _newclass:oamY1731Opcode = _swig_property(_OFDPA_python.ofdpaMplsMpFlowMatch_t_oamY1731Opcode_get, _OFDPA_python.ofdpaMplsMpFlowMatch_t_oamY1731Opcode_set)
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaMplsMpFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaMplsMpFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaMplsMpFlowMatch_t_etherType_get, _OFDPA_python.ofdpaMplsMpFlowMatch_t_etherType_set)
    def __init__(self): 
        """__init__(ofdpaMplsMpFlowMatch_s self) -> ofdpaMplsMpFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaMplsMpFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMplsMpFlowMatch_t
    __del__ = lambda self : None;
ofdpaMplsMpFlowMatch_t_swigregister = _OFDPA_python.ofdpaMplsMpFlowMatch_t_swigregister
ofdpaMplsMpFlowMatch_t_swigregister(ofdpaMplsMpFlowMatch_t)

class ofdpaMplsMpFlowEntry_t(_object):
    """Proxy of C ofdpaMplsMpFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMplsMpFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMplsMpFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaMplsMpFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaMplsMpFlowEntry_t_match_criteria_set)
    __swig_setmethods__["clearAction"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_clearAction_set
    __swig_getmethods__["clearAction"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_clearAction_get
    if _newclass:clearAction = _swig_property(_OFDPA_python.ofdpaMplsMpFlowEntry_t_clearAction_get, _OFDPA_python.ofdpaMplsMpFlowEntry_t_clearAction_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaMplsMpFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaMplsMpFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["oamSetCounterFieldsAction"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_oamSetCounterFieldsAction_set
    __swig_getmethods__["oamSetCounterFieldsAction"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_oamSetCounterFieldsAction_get
    if _newclass:oamSetCounterFieldsAction = _swig_property(_OFDPA_python.ofdpaMplsMpFlowEntry_t_oamSetCounterFieldsAction_get, _OFDPA_python.ofdpaMplsMpFlowEntry_t_oamSetCounterFieldsAction_set)
    __swig_setmethods__["checkDropStatusAction"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_checkDropStatusAction_set
    __swig_getmethods__["checkDropStatusAction"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_checkDropStatusAction_get
    if _newclass:checkDropStatusAction = _swig_property(_OFDPA_python.ofdpaMplsMpFlowEntry_t_checkDropStatusAction_get, _OFDPA_python.ofdpaMplsMpFlowEntry_t_checkDropStatusAction_set)
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaMplsMpFlowEntry_t_lmepId_get, _OFDPA_python.ofdpaMplsMpFlowEntry_t_lmepId_set)
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaMplsMpFlowEntry_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaMplsMpFlowEntry_t_outputPort_get, _OFDPA_python.ofdpaMplsMpFlowEntry_t_outputPort_set)
    def __init__(self): 
        """__init__(ofdpaMplsMpFlowEntry_s self) -> ofdpaMplsMpFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaMplsMpFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMplsMpFlowEntry_t
    __del__ = lambda self : None;
ofdpaMplsMpFlowEntry_t_swigregister = _OFDPA_python.ofdpaMplsMpFlowEntry_t_swigregister
ofdpaMplsMpFlowEntry_t_swigregister(ofdpaMplsMpFlowEntry_t)

class ofdpaUnicastRoutingFlowMatch_t(_object):
    """Proxy of C ofdpaUnicastRoutingFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaUnicastRoutingFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaUnicastRoutingFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_etherType_get, _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_etherType_set)
    __swig_setmethods__["vrf"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_vrf_set
    __swig_getmethods__["vrf"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_vrf_get
    if _newclass:vrf = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_vrf_get, _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_vrf_set)
    __swig_setmethods__["vrfMask"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_vrfMask_set
    __swig_getmethods__["vrfMask"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_vrfMask_get
    if _newclass:vrfMask = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_vrfMask_get, _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_vrfMask_set)
    __swig_setmethods__["dstIp4"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp4_set
    __swig_getmethods__["dstIp4"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp4_get
    if _newclass:dstIp4 = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp4_get, _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp4_set)
    __swig_setmethods__["dstIp4Mask"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp4Mask_set
    __swig_getmethods__["dstIp4Mask"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp4Mask_get
    if _newclass:dstIp4Mask = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp4Mask_get, _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp4Mask_set)
    __swig_setmethods__["dstIp6"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp6_set
    __swig_getmethods__["dstIp6"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp6_get
    if _newclass:dstIp6 = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp6_get, _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp6_set)
    __swig_setmethods__["dstIp6Mask"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp6Mask_set
    __swig_getmethods__["dstIp6Mask"] = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp6Mask_get
    if _newclass:dstIp6Mask = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp6Mask_get, _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_dstIp6Mask_set)
    def __init__(self): 
        """__init__(ofdpaUnicastRoutingFlowMatch_s self) -> ofdpaUnicastRoutingFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaUnicastRoutingFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaUnicastRoutingFlowMatch_t
    __del__ = lambda self : None;
ofdpaUnicastRoutingFlowMatch_t_swigregister = _OFDPA_python.ofdpaUnicastRoutingFlowMatch_t_swigregister
ofdpaUnicastRoutingFlowMatch_t_swigregister(ofdpaUnicastRoutingFlowMatch_t)

class ofdpaUnicastRoutingFlowEntry_t(_object):
    """Proxy of C ofdpaUnicastRoutingFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaUnicastRoutingFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaUnicastRoutingFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["groupID"] = _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_groupID_set
    __swig_getmethods__["groupID"] = _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_groupID_get
    if _newclass:groupID = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_groupID_get, _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_groupID_set)
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_outputPort_get, _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_outputPort_set)
    def __init__(self): 
        """__init__(ofdpaUnicastRoutingFlowEntry_s self) -> ofdpaUnicastRoutingFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaUnicastRoutingFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaUnicastRoutingFlowEntry_t
    __del__ = lambda self : None;
ofdpaUnicastRoutingFlowEntry_t_swigregister = _OFDPA_python.ofdpaUnicastRoutingFlowEntry_t_swigregister
ofdpaUnicastRoutingFlowEntry_t_swigregister(ofdpaUnicastRoutingFlowEntry_t)

class ofdpaMulticastRoutingFlowMatch_t(_object):
    """Proxy of C ofdpaMulticastRoutingFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMulticastRoutingFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMulticastRoutingFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_etherType_get, _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_etherType_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vlanId_get, _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vlanId_set)
    __swig_setmethods__["vrf"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vrf_set
    __swig_getmethods__["vrf"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vrf_get
    if _newclass:vrf = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vrf_get, _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vrf_set)
    __swig_setmethods__["vrfMask"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vrfMask_set
    __swig_getmethods__["vrfMask"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vrfMask_get
    if _newclass:vrfMask = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vrfMask_get, _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_vrfMask_set)
    __swig_setmethods__["srcIp4"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp4_set
    __swig_getmethods__["srcIp4"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp4_get
    if _newclass:srcIp4 = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp4_get, _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp4_set)
    __swig_setmethods__["srcIp4Mask"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp4Mask_set
    __swig_getmethods__["srcIp4Mask"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp4Mask_get
    if _newclass:srcIp4Mask = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp4Mask_get, _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp4Mask_set)
    __swig_setmethods__["dstIp4"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_dstIp4_set
    __swig_getmethods__["dstIp4"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_dstIp4_get
    if _newclass:dstIp4 = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_dstIp4_get, _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_dstIp4_set)
    __swig_setmethods__["srcIp6"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp6_set
    __swig_getmethods__["srcIp6"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp6_get
    if _newclass:srcIp6 = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp6_get, _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp6_set)
    __swig_setmethods__["srcIp6Mask"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp6Mask_set
    __swig_getmethods__["srcIp6Mask"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp6Mask_get
    if _newclass:srcIp6Mask = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp6Mask_get, _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_srcIp6Mask_set)
    __swig_setmethods__["dstIp6"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_dstIp6_set
    __swig_getmethods__["dstIp6"] = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_dstIp6_get
    if _newclass:dstIp6 = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_dstIp6_get, _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_dstIp6_set)
    def __init__(self): 
        """__init__(ofdpaMulticastRoutingFlowMatch_s self) -> ofdpaMulticastRoutingFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaMulticastRoutingFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMulticastRoutingFlowMatch_t
    __del__ = lambda self : None;
ofdpaMulticastRoutingFlowMatch_t_swigregister = _OFDPA_python.ofdpaMulticastRoutingFlowMatch_t_swigregister
ofdpaMulticastRoutingFlowMatch_t_swigregister(ofdpaMulticastRoutingFlowMatch_t)

class ofdpaMulticastRoutingFlowEntry_t(_object):
    """Proxy of C ofdpaMulticastRoutingFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMulticastRoutingFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMulticastRoutingFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["groupID"] = _OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_groupID_set
    __swig_getmethods__["groupID"] = _OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_groupID_get
    if _newclass:groupID = _swig_property(_OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_groupID_get, _OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_groupID_set)
    def __init__(self): 
        """__init__(ofdpaMulticastRoutingFlowEntry_s self) -> ofdpaMulticastRoutingFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaMulticastRoutingFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMulticastRoutingFlowEntry_t
    __del__ = lambda self : None;
ofdpaMulticastRoutingFlowEntry_t_swigregister = _OFDPA_python.ofdpaMulticastRoutingFlowEntry_t_swigregister
ofdpaMulticastRoutingFlowEntry_t_swigregister(ofdpaMulticastRoutingFlowEntry_t)

class ofdpaBridgingFlowMatch_t(_object):
    """Proxy of C ofdpaBridgingFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaBridgingFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaBridgingFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaBridgingFlowMatch_t_vlanId_get, _OFDPA_python.ofdpaBridgingFlowMatch_t_vlanId_set)
    __swig_setmethods__["vlanIdMask"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_vlanIdMask_set
    __swig_getmethods__["vlanIdMask"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_vlanIdMask_get
    if _newclass:vlanIdMask = _swig_property(_OFDPA_python.ofdpaBridgingFlowMatch_t_vlanIdMask_get, _OFDPA_python.ofdpaBridgingFlowMatch_t_vlanIdMask_set)
    __swig_setmethods__["tunnelId"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_tunnelId_set
    __swig_getmethods__["tunnelId"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_tunnelId_get
    if _newclass:tunnelId = _swig_property(_OFDPA_python.ofdpaBridgingFlowMatch_t_tunnelId_get, _OFDPA_python.ofdpaBridgingFlowMatch_t_tunnelId_set)
    __swig_setmethods__["tunnelIdMask"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_tunnelIdMask_set
    __swig_getmethods__["tunnelIdMask"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_tunnelIdMask_get
    if _newclass:tunnelIdMask = _swig_property(_OFDPA_python.ofdpaBridgingFlowMatch_t_tunnelIdMask_get, _OFDPA_python.ofdpaBridgingFlowMatch_t_tunnelIdMask_set)
    __swig_setmethods__["destMac"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_destMac_set
    __swig_getmethods__["destMac"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_destMac_get
    if _newclass:destMac = _swig_property(_OFDPA_python.ofdpaBridgingFlowMatch_t_destMac_get, _OFDPA_python.ofdpaBridgingFlowMatch_t_destMac_set)
    __swig_setmethods__["destMacMask"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_destMacMask_set
    __swig_getmethods__["destMacMask"] = _OFDPA_python.ofdpaBridgingFlowMatch_t_destMacMask_get
    if _newclass:destMacMask = _swig_property(_OFDPA_python.ofdpaBridgingFlowMatch_t_destMacMask_get, _OFDPA_python.ofdpaBridgingFlowMatch_t_destMacMask_set)
    def __init__(self): 
        """__init__(ofdpaBridgingFlowMatch_s self) -> ofdpaBridgingFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaBridgingFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaBridgingFlowMatch_t
    __del__ = lambda self : None;
ofdpaBridgingFlowMatch_t_swigregister = _OFDPA_python.ofdpaBridgingFlowMatch_t_swigregister
ofdpaBridgingFlowMatch_t_swigregister(ofdpaBridgingFlowMatch_t)

class ofdpaBridgingFlowEntry_t(_object):
    """Proxy of C ofdpaBridgingFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaBridgingFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaBridgingFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaBridgingFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaBridgingFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaBridgingFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaBridgingFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaBridgingFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaBridgingFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaBridgingFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaBridgingFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["groupID"] = _OFDPA_python.ofdpaBridgingFlowEntry_t_groupID_set
    __swig_getmethods__["groupID"] = _OFDPA_python.ofdpaBridgingFlowEntry_t_groupID_get
    if _newclass:groupID = _swig_property(_OFDPA_python.ofdpaBridgingFlowEntry_t_groupID_get, _OFDPA_python.ofdpaBridgingFlowEntry_t_groupID_set)
    __swig_setmethods__["tunnelLogicalPort"] = _OFDPA_python.ofdpaBridgingFlowEntry_t_tunnelLogicalPort_set
    __swig_getmethods__["tunnelLogicalPort"] = _OFDPA_python.ofdpaBridgingFlowEntry_t_tunnelLogicalPort_get
    if _newclass:tunnelLogicalPort = _swig_property(_OFDPA_python.ofdpaBridgingFlowEntry_t_tunnelLogicalPort_get, _OFDPA_python.ofdpaBridgingFlowEntry_t_tunnelLogicalPort_set)
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaBridgingFlowEntry_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaBridgingFlowEntry_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaBridgingFlowEntry_t_outputPort_get, _OFDPA_python.ofdpaBridgingFlowEntry_t_outputPort_set)
    def __init__(self): 
        """__init__(ofdpaBridgingFlowEntry_s self) -> ofdpaBridgingFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaBridgingFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaBridgingFlowEntry_t
    __del__ = lambda self : None;
ofdpaBridgingFlowEntry_t_swigregister = _OFDPA_python.ofdpaBridgingFlowEntry_t_swigregister
ofdpaBridgingFlowEntry_t_swigregister(ofdpaBridgingFlowEntry_t)

class ofdpaL2PolicerFlowMatch_t(_object):
    """Proxy of C ofdpaL2PolicerFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaL2PolicerFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaL2PolicerFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tunnelId"] = _OFDPA_python.ofdpaL2PolicerFlowMatch_t_tunnelId_set
    __swig_getmethods__["tunnelId"] = _OFDPA_python.ofdpaL2PolicerFlowMatch_t_tunnelId_get
    if _newclass:tunnelId = _swig_property(_OFDPA_python.ofdpaL2PolicerFlowMatch_t_tunnelId_get, _OFDPA_python.ofdpaL2PolicerFlowMatch_t_tunnelId_set)
    __swig_setmethods__["mplsL2Port"] = _OFDPA_python.ofdpaL2PolicerFlowMatch_t_mplsL2Port_set
    __swig_getmethods__["mplsL2Port"] = _OFDPA_python.ofdpaL2PolicerFlowMatch_t_mplsL2Port_get
    if _newclass:mplsL2Port = _swig_property(_OFDPA_python.ofdpaL2PolicerFlowMatch_t_mplsL2Port_get, _OFDPA_python.ofdpaL2PolicerFlowMatch_t_mplsL2Port_set)
    __swig_setmethods__["mplsL2PortMask"] = _OFDPA_python.ofdpaL2PolicerFlowMatch_t_mplsL2PortMask_set
    __swig_getmethods__["mplsL2PortMask"] = _OFDPA_python.ofdpaL2PolicerFlowMatch_t_mplsL2PortMask_get
    if _newclass:mplsL2PortMask = _swig_property(_OFDPA_python.ofdpaL2PolicerFlowMatch_t_mplsL2PortMask_get, _OFDPA_python.ofdpaL2PolicerFlowMatch_t_mplsL2PortMask_set)
    def __init__(self): 
        """__init__(ofdpaL2PolicerFlowMatch_s self) -> ofdpaL2PolicerFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaL2PolicerFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaL2PolicerFlowMatch_t
    __del__ = lambda self : None;
ofdpaL2PolicerFlowMatch_t_swigregister = _OFDPA_python.ofdpaL2PolicerFlowMatch_t_swigregister
ofdpaL2PolicerFlowMatch_t_swigregister(ofdpaL2PolicerFlowMatch_t)

class ofdpaL2PolicerFlowEntry_t(_object):
    """Proxy of C ofdpaL2PolicerFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaL2PolicerFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaL2PolicerFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaL2PolicerFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaL2PolicerFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaL2PolicerFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaL2PolicerFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaL2PolicerFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaL2PolicerFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaL2PolicerFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaL2PolicerFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["meterId"] = _OFDPA_python.ofdpaL2PolicerFlowEntry_t_meterId_set
    __swig_getmethods__["meterId"] = _OFDPA_python.ofdpaL2PolicerFlowEntry_t_meterId_get
    if _newclass:meterId = _swig_property(_OFDPA_python.ofdpaL2PolicerFlowEntry_t_meterId_get, _OFDPA_python.ofdpaL2PolicerFlowEntry_t_meterId_set)
    __swig_setmethods__["colorActionsIndex"] = _OFDPA_python.ofdpaL2PolicerFlowEntry_t_colorActionsIndex_set
    __swig_getmethods__["colorActionsIndex"] = _OFDPA_python.ofdpaL2PolicerFlowEntry_t_colorActionsIndex_get
    if _newclass:colorActionsIndex = _swig_property(_OFDPA_python.ofdpaL2PolicerFlowEntry_t_colorActionsIndex_get, _OFDPA_python.ofdpaL2PolicerFlowEntry_t_colorActionsIndex_set)
    def __init__(self): 
        """__init__(ofdpaL2PolicerFlowEntry_s self) -> ofdpaL2PolicerFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaL2PolicerFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaL2PolicerFlowEntry_t
    __del__ = lambda self : None;
ofdpaL2PolicerFlowEntry_t_swigregister = _OFDPA_python.ofdpaL2PolicerFlowEntry_t_swigregister
ofdpaL2PolicerFlowEntry_t_swigregister(ofdpaL2PolicerFlowEntry_t)

class ofdpaL2PolicerActionsFlowMatch_t(_object):
    """Proxy of C ofdpaL2PolicerActionsFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaL2PolicerActionsFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaL2PolicerActionsFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["color"] = _OFDPA_python.ofdpaL2PolicerActionsFlowMatch_t_color_set
    __swig_getmethods__["color"] = _OFDPA_python.ofdpaL2PolicerActionsFlowMatch_t_color_get
    if _newclass:color = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowMatch_t_color_get, _OFDPA_python.ofdpaL2PolicerActionsFlowMatch_t_color_set)
    __swig_setmethods__["colorActionsIndex"] = _OFDPA_python.ofdpaL2PolicerActionsFlowMatch_t_colorActionsIndex_set
    __swig_getmethods__["colorActionsIndex"] = _OFDPA_python.ofdpaL2PolicerActionsFlowMatch_t_colorActionsIndex_get
    if _newclass:colorActionsIndex = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowMatch_t_colorActionsIndex_get, _OFDPA_python.ofdpaL2PolicerActionsFlowMatch_t_colorActionsIndex_set)
    def __init__(self): 
        """__init__(ofdpaL2PolicerActionsFlowMatch_s self) -> ofdpaL2PolicerActionsFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaL2PolicerActionsFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaL2PolicerActionsFlowMatch_t
    __del__ = lambda self : None;
ofdpaL2PolicerActionsFlowMatch_t_swigregister = _OFDPA_python.ofdpaL2PolicerActionsFlowMatch_t_swigregister
ofdpaL2PolicerActionsFlowMatch_t_swigregister(ofdpaL2PolicerActionsFlowMatch_t)

class ofdpaL2PolicerActionsFlowEntry_t(_object):
    """Proxy of C ofdpaL2PolicerActionsFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaL2PolicerActionsFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaL2PolicerActionsFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["clearAction"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_clearAction_set
    __swig_getmethods__["clearAction"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_clearAction_get
    if _newclass:clearAction = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_clearAction_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_clearAction_set)
    __swig_setmethods__["dscpAction"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_dscpAction_set
    __swig_getmethods__["dscpAction"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_dscpAction_get
    if _newclass:dscpAction = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_dscpAction_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_dscpAction_set)
    __swig_setmethods__["dscp"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_dscp_set
    __swig_getmethods__["dscp"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_dscp_get
    if _newclass:dscp = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_dscp_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_dscp_set)
    __swig_setmethods__["ecnAction"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_ecnAction_set
    __swig_getmethods__["ecnAction"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_ecnAction_get
    if _newclass:ecnAction = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_ecnAction_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_ecnAction_set)
    __swig_setmethods__["ecn"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_ecn_set
    __swig_getmethods__["ecn"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_ecn_get
    if _newclass:ecn = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_ecn_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_ecn_set)
    __swig_setmethods__["vlanPcpAction"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_vlanPcpAction_set
    __swig_getmethods__["vlanPcpAction"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_vlanPcpAction_get
    if _newclass:vlanPcpAction = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_vlanPcpAction_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_vlanPcpAction_set)
    __swig_setmethods__["vlanPcp"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_vlanPcp_set
    __swig_getmethods__["vlanPcp"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_vlanPcp_get
    if _newclass:vlanPcp = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_vlanPcp_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_vlanPcp_set)
    __swig_setmethods__["trafficClassAction"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_trafficClassAction_set
    __swig_getmethods__["trafficClassAction"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_trafficClassAction_get
    if _newclass:trafficClassAction = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_trafficClassAction_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_trafficClassAction_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_trafficClass_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_trafficClass_set)
    __swig_setmethods__["colorActionsIndex"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_colorActionsIndex_set
    __swig_getmethods__["colorActionsIndex"] = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_colorActionsIndex_get
    if _newclass:colorActionsIndex = _swig_property(_OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_colorActionsIndex_get, _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_colorActionsIndex_set)
    def __init__(self): 
        """__init__(ofdpaL2PolicerActionsFlowEntry_s self) -> ofdpaL2PolicerActionsFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaL2PolicerActionsFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaL2PolicerActionsFlowEntry_t
    __del__ = lambda self : None;
ofdpaL2PolicerActionsFlowEntry_t_swigregister = _OFDPA_python.ofdpaL2PolicerActionsFlowEntry_t_swigregister
ofdpaL2PolicerActionsFlowEntry_t_swigregister(ofdpaL2PolicerActionsFlowEntry_t)

class ofdpaPolicyAclFlowMatch_t(_object):
    """Proxy of C ofdpaPolicyAclFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaPolicyAclFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaPolicyAclFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["inPort"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_inPort_set
    __swig_getmethods__["inPort"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_inPort_get
    if _newclass:inPort = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_inPort_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_inPort_set)
    __swig_setmethods__["inPortMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_inPortMask_set
    __swig_getmethods__["inPortMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_inPortMask_get
    if _newclass:inPortMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_inPortMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_inPortMask_set)
    __swig_setmethods__["mplsL2Port"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_mplsL2Port_set
    __swig_getmethods__["mplsL2Port"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_mplsL2Port_get
    if _newclass:mplsL2Port = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_mplsL2Port_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_mplsL2Port_set)
    __swig_setmethods__["mplsL2PortMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_mplsL2PortMask_set
    __swig_getmethods__["mplsL2PortMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_mplsL2PortMask_get
    if _newclass:mplsL2PortMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_mplsL2PortMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_mplsL2PortMask_set)
    __swig_setmethods__["srcMac"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcMac_set
    __swig_getmethods__["srcMac"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcMac_get
    if _newclass:srcMac = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcMac_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcMac_set)
    __swig_setmethods__["srcMacMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcMacMask_set
    __swig_getmethods__["srcMacMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcMacMask_get
    if _newclass:srcMacMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcMacMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcMacMask_set)
    __swig_setmethods__["destMac"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destMac_set
    __swig_getmethods__["destMac"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destMac_get
    if _newclass:destMac = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_destMac_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destMac_set)
    __swig_setmethods__["destMacMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destMacMask_set
    __swig_getmethods__["destMacMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destMacMask_get
    if _newclass:destMacMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_destMacMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destMacMask_set)
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_etherType_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_etherType_set)
    __swig_setmethods__["etherTypeMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_etherTypeMask_set
    __swig_getmethods__["etherTypeMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_etherTypeMask_get
    if _newclass:etherTypeMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_etherTypeMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_etherTypeMask_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanId_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanId_set)
    __swig_setmethods__["vlanIdMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanIdMask_set
    __swig_getmethods__["vlanIdMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanIdMask_get
    if _newclass:vlanIdMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanIdMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanIdMask_set)
    __swig_setmethods__["vlanPcp"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanPcp_set
    __swig_getmethods__["vlanPcp"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanPcp_get
    if _newclass:vlanPcp = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanPcp_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanPcp_set)
    __swig_setmethods__["vlanPcpMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanPcpMask_set
    __swig_getmethods__["vlanPcpMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanPcpMask_get
    if _newclass:vlanPcpMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanPcpMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanPcpMask_set)
    __swig_setmethods__["vlanDei"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanDei_set
    __swig_getmethods__["vlanDei"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanDei_get
    if _newclass:vlanDei = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanDei_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanDei_set)
    __swig_setmethods__["vlanDeiMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanDeiMask_set
    __swig_getmethods__["vlanDeiMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanDeiMask_get
    if _newclass:vlanDeiMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanDeiMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vlanDeiMask_set)
    __swig_setmethods__["tunnelId"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_tunnelId_set
    __swig_getmethods__["tunnelId"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_tunnelId_get
    if _newclass:tunnelId = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_tunnelId_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_tunnelId_set)
    __swig_setmethods__["tunnelIdMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_tunnelIdMask_set
    __swig_getmethods__["tunnelIdMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_tunnelIdMask_get
    if _newclass:tunnelIdMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_tunnelIdMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_tunnelIdMask_set)
    __swig_setmethods__["vrf"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vrf_set
    __swig_getmethods__["vrf"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vrf_get
    if _newclass:vrf = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_vrf_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vrf_set)
    __swig_setmethods__["vrfMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vrfMask_set
    __swig_getmethods__["vrfMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vrfMask_get
    if _newclass:vrfMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_vrfMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_vrfMask_set)
    __swig_setmethods__["sourceIp4"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp4_set
    __swig_getmethods__["sourceIp4"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp4_get
    if _newclass:sourceIp4 = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp4_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp4_set)
    __swig_setmethods__["sourceIp4Mask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp4Mask_set
    __swig_getmethods__["sourceIp4Mask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp4Mask_get
    if _newclass:sourceIp4Mask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp4Mask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp4Mask_set)
    __swig_setmethods__["destIp4"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp4_set
    __swig_getmethods__["destIp4"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp4_get
    if _newclass:destIp4 = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp4_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp4_set)
    __swig_setmethods__["destIp4Mask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp4Mask_set
    __swig_getmethods__["destIp4Mask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp4Mask_get
    if _newclass:destIp4Mask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp4Mask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp4Mask_set)
    __swig_setmethods__["sourceIp6"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp6_set
    __swig_getmethods__["sourceIp6"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp6_get
    if _newclass:sourceIp6 = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp6_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp6_set)
    __swig_setmethods__["sourceIp6Mask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp6Mask_set
    __swig_getmethods__["sourceIp6Mask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp6Mask_get
    if _newclass:sourceIp6Mask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp6Mask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_sourceIp6Mask_set)
    __swig_setmethods__["destIp6"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp6_set
    __swig_getmethods__["destIp6"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp6_get
    if _newclass:destIp6 = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp6_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp6_set)
    __swig_setmethods__["destIp6Mask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp6Mask_set
    __swig_getmethods__["destIp6Mask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp6Mask_get
    if _newclass:destIp6Mask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp6Mask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destIp6Mask_set)
    __swig_setmethods__["ipv4ArpSpa"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv4ArpSpa_set
    __swig_getmethods__["ipv4ArpSpa"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv4ArpSpa_get
    if _newclass:ipv4ArpSpa = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv4ArpSpa_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv4ArpSpa_set)
    __swig_setmethods__["ipv4ArpSpaMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv4ArpSpaMask_set
    __swig_getmethods__["ipv4ArpSpaMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv4ArpSpaMask_get
    if _newclass:ipv4ArpSpaMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv4ArpSpaMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv4ArpSpaMask_set)
    __swig_setmethods__["ipProto"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipProto_set
    __swig_getmethods__["ipProto"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipProto_get
    if _newclass:ipProto = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipProto_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipProto_set)
    __swig_setmethods__["ipProtoMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipProtoMask_set
    __swig_getmethods__["ipProtoMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipProtoMask_get
    if _newclass:ipProtoMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipProtoMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipProtoMask_set)
    __swig_setmethods__["dscp"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_dscp_set
    __swig_getmethods__["dscp"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_dscp_get
    if _newclass:dscp = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_dscp_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_dscp_set)
    __swig_setmethods__["dscpMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_dscpMask_set
    __swig_getmethods__["dscpMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_dscpMask_get
    if _newclass:dscpMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_dscpMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_dscpMask_set)
    __swig_setmethods__["ecn"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ecn_set
    __swig_getmethods__["ecn"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ecn_get
    if _newclass:ecn = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_ecn_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ecn_set)
    __swig_setmethods__["ecnMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ecnMask_set
    __swig_getmethods__["ecnMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ecnMask_get
    if _newclass:ecnMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_ecnMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ecnMask_set)
    __swig_setmethods__["srcL4Port"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcL4Port_set
    __swig_getmethods__["srcL4Port"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcL4Port_get
    if _newclass:srcL4Port = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcL4Port_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcL4Port_set)
    __swig_setmethods__["srcL4PortMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcL4PortMask_set
    __swig_getmethods__["srcL4PortMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcL4PortMask_get
    if _newclass:srcL4PortMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcL4PortMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_srcL4PortMask_set)
    __swig_setmethods__["destL4Port"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destL4Port_set
    __swig_getmethods__["destL4Port"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destL4Port_get
    if _newclass:destL4Port = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_destL4Port_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destL4Port_set)
    __swig_setmethods__["destL4PortMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destL4PortMask_set
    __swig_getmethods__["destL4PortMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destL4PortMask_get
    if _newclass:destL4PortMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_destL4PortMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_destL4PortMask_set)
    __swig_setmethods__["icmpType"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpType_set
    __swig_getmethods__["icmpType"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpType_get
    if _newclass:icmpType = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpType_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpType_set)
    __swig_setmethods__["icmpTypeMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpTypeMask_set
    __swig_getmethods__["icmpTypeMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpTypeMask_get
    if _newclass:icmpTypeMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpTypeMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpTypeMask_set)
    __swig_setmethods__["icmpCode"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpCode_set
    __swig_getmethods__["icmpCode"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpCode_get
    if _newclass:icmpCode = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpCode_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpCode_set)
    __swig_setmethods__["icmpCodeMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpCodeMask_set
    __swig_getmethods__["icmpCodeMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpCodeMask_get
    if _newclass:icmpCodeMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpCodeMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_icmpCodeMask_set)
    __swig_setmethods__["ipv6FlowLabel"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv6FlowLabel_set
    __swig_getmethods__["ipv6FlowLabel"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv6FlowLabel_get
    if _newclass:ipv6FlowLabel = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv6FlowLabel_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv6FlowLabel_set)
    __swig_setmethods__["ipv6FlowLabelMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv6FlowLabelMask_set
    __swig_getmethods__["ipv6FlowLabelMask"] = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv6FlowLabelMask_get
    if _newclass:ipv6FlowLabelMask = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv6FlowLabelMask_get, _OFDPA_python.ofdpaPolicyAclFlowMatch_t_ipv6FlowLabelMask_set)
    def __init__(self): 
        """__init__(ofdpaPolicyAclFlowMatch_s self) -> ofdpaPolicyAclFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaPolicyAclFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaPolicyAclFlowMatch_t
    __del__ = lambda self : None;
ofdpaPolicyAclFlowMatch_t_swigregister = _OFDPA_python.ofdpaPolicyAclFlowMatch_t_swigregister
ofdpaPolicyAclFlowMatch_t_swigregister(ofdpaPolicyAclFlowMatch_t)

class ofdpaPolicyAclFlowEntry_t(_object):
    """Proxy of C ofdpaPolicyAclFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaPolicyAclFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaPolicyAclFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_match_criteria_set)
    __swig_setmethods__["vlanPcpAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_vlanPcpAction_set
    __swig_getmethods__["vlanPcpAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_vlanPcpAction_get
    if _newclass:vlanPcpAction = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_vlanPcpAction_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_vlanPcpAction_set)
    __swig_setmethods__["vlanPcp"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_vlanPcp_set
    __swig_getmethods__["vlanPcp"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_vlanPcp_get
    if _newclass:vlanPcp = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_vlanPcp_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_vlanPcp_set)
    __swig_setmethods__["trafficClassAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_trafficClassAction_set
    __swig_getmethods__["trafficClassAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_trafficClassAction_get
    if _newclass:trafficClassAction = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_trafficClassAction_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_trafficClassAction_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_trafficClass_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_trafficClass_set)
    __swig_setmethods__["colorAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorAction_set
    __swig_getmethods__["colorAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorAction_get
    if _newclass:colorAction = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorAction_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorAction_set)
    __swig_setmethods__["color"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_color_set
    __swig_getmethods__["color"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_color_get
    if _newclass:color = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_color_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_color_set)
    __swig_setmethods__["colorEntryIdAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorEntryIdAction_set
    __swig_getmethods__["colorEntryIdAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorEntryIdAction_get
    if _newclass:colorEntryIdAction = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorEntryIdAction_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorEntryIdAction_set)
    __swig_setmethods__["colorEntryId"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorEntryId_set
    __swig_getmethods__["colorEntryId"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorEntryId_get
    if _newclass:colorEntryId = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorEntryId_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_colorEntryId_set)
    __swig_setmethods__["ecnAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_ecnAction_set
    __swig_getmethods__["ecnAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_ecnAction_get
    if _newclass:ecnAction = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_ecnAction_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_ecnAction_set)
    __swig_setmethods__["ecn"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_ecn_set
    __swig_getmethods__["ecn"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_ecn_get
    if _newclass:ecn = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_ecn_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_ecn_set)
    __swig_setmethods__["dscpAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_dscpAction_set
    __swig_getmethods__["dscpAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_dscpAction_get
    if _newclass:dscpAction = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_dscpAction_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_dscpAction_set)
    __swig_setmethods__["dscp"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_dscp_set
    __swig_getmethods__["dscp"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_dscp_get
    if _newclass:dscp = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_dscp_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_dscp_set)
    __swig_setmethods__["groupID"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_groupID_set
    __swig_getmethods__["groupID"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_groupID_get
    if _newclass:groupID = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_groupID_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_groupID_set)
    __swig_setmethods__["outputTunnelPort"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_outputTunnelPort_set
    __swig_getmethods__["outputTunnelPort"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_outputTunnelPort_get
    if _newclass:outputTunnelPort = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_outputTunnelPort_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_outputTunnelPort_set)
    __swig_setmethods__["meterIdAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_meterIdAction_set
    __swig_getmethods__["meterIdAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_meterIdAction_get
    if _newclass:meterIdAction = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_meterIdAction_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_meterIdAction_set)
    __swig_setmethods__["meterId"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_meterId_set
    __swig_getmethods__["meterId"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_meterId_get
    if _newclass:meterId = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_meterId_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_meterId_set)
    __swig_setmethods__["gotoTable"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_gotoTable_set
    __swig_getmethods__["gotoTable"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_gotoTable_get
    if _newclass:gotoTable = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_gotoTable_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_gotoTable_set)
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_outputPort_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_outputPort_set)
    __swig_setmethods__["clearAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_clearAction_set
    __swig_getmethods__["clearAction"] = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_clearAction_get
    if _newclass:clearAction = _swig_property(_OFDPA_python.ofdpaPolicyAclFlowEntry_t_clearAction_get, _OFDPA_python.ofdpaPolicyAclFlowEntry_t_clearAction_set)
    def __init__(self): 
        """__init__(ofdpaPolicyAclFlowEntry_s self) -> ofdpaPolicyAclFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaPolicyAclFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaPolicyAclFlowEntry_t
    __del__ = lambda self : None;
ofdpaPolicyAclFlowEntry_t_swigregister = _OFDPA_python.ofdpaPolicyAclFlowEntry_t_swigregister
ofdpaPolicyAclFlowEntry_t_swigregister(ofdpaPolicyAclFlowEntry_t)

class ofdpaColorActionsFlowMatch_t(_object):
    """Proxy of C ofdpaColorActionsFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaColorActionsFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaColorActionsFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["color"] = _OFDPA_python.ofdpaColorActionsFlowMatch_t_color_set
    __swig_getmethods__["color"] = _OFDPA_python.ofdpaColorActionsFlowMatch_t_color_get
    if _newclass:color = _swig_property(_OFDPA_python.ofdpaColorActionsFlowMatch_t_color_get, _OFDPA_python.ofdpaColorActionsFlowMatch_t_color_set)
    __swig_setmethods__["index"] = _OFDPA_python.ofdpaColorActionsFlowMatch_t_index_set
    __swig_getmethods__["index"] = _OFDPA_python.ofdpaColorActionsFlowMatch_t_index_get
    if _newclass:index = _swig_property(_OFDPA_python.ofdpaColorActionsFlowMatch_t_index_get, _OFDPA_python.ofdpaColorActionsFlowMatch_t_index_set)
    def __init__(self): 
        """__init__(ofdpaColorActionsFlowMatch_s self) -> ofdpaColorActionsFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaColorActionsFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaColorActionsFlowMatch_t
    __del__ = lambda self : None;
ofdpaColorActionsFlowMatch_t_swigregister = _OFDPA_python.ofdpaColorActionsFlowMatch_t_swigregister
ofdpaColorActionsFlowMatch_t_swigregister(ofdpaColorActionsFlowMatch_t)

class ofdpaColorActionsFlowEntry_t(_object):
    """Proxy of C ofdpaColorActionsFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaColorActionsFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaColorActionsFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_match_criteria_set)
    __swig_setmethods__["clearAction"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_clearAction_set
    __swig_getmethods__["clearAction"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_clearAction_get
    if _newclass:clearAction = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_clearAction_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_clearAction_set)
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_outputPort_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_outputPort_set)
    __swig_setmethods__["trafficClassAction"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_trafficClassAction_set
    __swig_getmethods__["trafficClassAction"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_trafficClassAction_get
    if _newclass:trafficClassAction = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_trafficClassAction_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_trafficClassAction_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_trafficClass_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_trafficClass_set)
    __swig_setmethods__["vlanPcpAction"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_vlanPcpAction_set
    __swig_getmethods__["vlanPcpAction"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_vlanPcpAction_get
    if _newclass:vlanPcpAction = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_vlanPcpAction_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_vlanPcpAction_set)
    __swig_setmethods__["vlanPcp"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_vlanPcp_set
    __swig_getmethods__["vlanPcp"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_vlanPcp_get
    if _newclass:vlanPcp = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_vlanPcp_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_vlanPcp_set)
    __swig_setmethods__["ecnAction"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_ecnAction_set
    __swig_getmethods__["ecnAction"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_ecnAction_get
    if _newclass:ecnAction = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_ecnAction_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_ecnAction_set)
    __swig_setmethods__["ecn"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_ecn_set
    __swig_getmethods__["ecn"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_ecn_get
    if _newclass:ecn = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_ecn_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_ecn_set)
    __swig_setmethods__["dscpAction"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_dscpAction_set
    __swig_getmethods__["dscpAction"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_dscpAction_get
    if _newclass:dscpAction = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_dscpAction_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_dscpAction_set)
    __swig_setmethods__["dscp"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_dscp_set
    __swig_getmethods__["dscp"] = _OFDPA_python.ofdpaColorActionsFlowEntry_t_dscp_get
    if _newclass:dscp = _swig_property(_OFDPA_python.ofdpaColorActionsFlowEntry_t_dscp_get, _OFDPA_python.ofdpaColorActionsFlowEntry_t_dscp_set)
    def __init__(self): 
        """__init__(ofdpaColorActionsFlowEntry_s self) -> ofdpaColorActionsFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaColorActionsFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaColorActionsFlowEntry_t
    __del__ = lambda self : None;
ofdpaColorActionsFlowEntry_t_swigregister = _OFDPA_python.ofdpaColorActionsFlowEntry_t_swigregister
ofdpaColorActionsFlowEntry_t_swigregister(ofdpaColorActionsFlowEntry_t)

class ofdpaEgressVlanFlowMatch_t(_object):
    """Proxy of C ofdpaEgressVlanFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEgressVlanFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEgressVlanFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["outPort"] = _OFDPA_python.ofdpaEgressVlanFlowMatch_t_outPort_set
    __swig_getmethods__["outPort"] = _OFDPA_python.ofdpaEgressVlanFlowMatch_t_outPort_get
    if _newclass:outPort = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowMatch_t_outPort_get, _OFDPA_python.ofdpaEgressVlanFlowMatch_t_outPort_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaEgressVlanFlowMatch_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaEgressVlanFlowMatch_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowMatch_t_vlanId_get, _OFDPA_python.ofdpaEgressVlanFlowMatch_t_vlanId_set)
    __swig_setmethods__["allowVlanTranslation"] = _OFDPA_python.ofdpaEgressVlanFlowMatch_t_allowVlanTranslation_set
    __swig_getmethods__["allowVlanTranslation"] = _OFDPA_python.ofdpaEgressVlanFlowMatch_t_allowVlanTranslation_get
    if _newclass:allowVlanTranslation = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowMatch_t_allowVlanTranslation_get, _OFDPA_python.ofdpaEgressVlanFlowMatch_t_allowVlanTranslation_set)
    def __init__(self): 
        """__init__(ofdpaEgressVlanFlowMatch_s self) -> ofdpaEgressVlanFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaEgressVlanFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEgressVlanFlowMatch_t
    __del__ = lambda self : None;
ofdpaEgressVlanFlowMatch_t_swigregister = _OFDPA_python.ofdpaEgressVlanFlowMatch_t_swigregister
ofdpaEgressVlanFlowMatch_t_swigregister(ofdpaEgressVlanFlowMatch_t)

class ofdpaEgressVlanFlowEntry_t(_object):
    """Proxy of C ofdpaEgressVlanFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEgressVlanFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEgressVlanFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["setVlanIdAction"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_setVlanIdAction_set
    __swig_getmethods__["setVlanIdAction"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_setVlanIdAction_get
    if _newclass:setVlanIdAction = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_setVlanIdAction_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_setVlanIdAction_set)
    __swig_setmethods__["newVlanId"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_newVlanId_set
    __swig_getmethods__["newVlanId"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_newVlanId_get
    if _newclass:newVlanId = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_newVlanId_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_newVlanId_set)
    __swig_setmethods__["popVlanAction"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_popVlanAction_set
    __swig_getmethods__["popVlanAction"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_popVlanAction_get
    if _newclass:popVlanAction = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_popVlanAction_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_popVlanAction_set)
    __swig_setmethods__["pushVlan2Action"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_pushVlan2Action_set
    __swig_getmethods__["pushVlan2Action"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_pushVlan2Action_get
    if _newclass:pushVlan2Action = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_pushVlan2Action_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_pushVlan2Action_set)
    __swig_setmethods__["newTpid2"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_newTpid2_set
    __swig_getmethods__["newTpid2"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_newTpid2_get
    if _newclass:newTpid2 = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_newTpid2_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_newTpid2_set)
    __swig_setmethods__["setVlanId2Action"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_setVlanId2Action_set
    __swig_getmethods__["setVlanId2Action"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_setVlanId2Action_get
    if _newclass:setVlanId2Action = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_setVlanId2Action_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_setVlanId2Action_set)
    __swig_setmethods__["newVlanId2"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_newVlanId2_set
    __swig_getmethods__["newVlanId2"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_newVlanId2_get
    if _newclass:newVlanId2 = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_newVlanId2_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_newVlanId2_set)
    __swig_setmethods__["ovidAction"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_ovidAction_set
    __swig_getmethods__["ovidAction"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_ovidAction_get
    if _newclass:ovidAction = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_ovidAction_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_ovidAction_set)
    __swig_setmethods__["ovid"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_ovid_set
    __swig_getmethods__["ovid"] = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_ovid_get
    if _newclass:ovid = _swig_property(_OFDPA_python.ofdpaEgressVlanFlowEntry_t_ovid_get, _OFDPA_python.ofdpaEgressVlanFlowEntry_t_ovid_set)
    def __init__(self): 
        """__init__(ofdpaEgressVlanFlowEntry_s self) -> ofdpaEgressVlanFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaEgressVlanFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEgressVlanFlowEntry_t
    __del__ = lambda self : None;
ofdpaEgressVlanFlowEntry_t_swigregister = _OFDPA_python.ofdpaEgressVlanFlowEntry_t_swigregister
ofdpaEgressVlanFlowEntry_t_swigregister(ofdpaEgressVlanFlowEntry_t)

class ofdpaEgressVlan1FlowMatch_t(_object):
    """Proxy of C ofdpaEgressVlan1FlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEgressVlan1FlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEgressVlan1FlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["outPort"] = _OFDPA_python.ofdpaEgressVlan1FlowMatch_t_outPort_set
    __swig_getmethods__["outPort"] = _OFDPA_python.ofdpaEgressVlan1FlowMatch_t_outPort_get
    if _newclass:outPort = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowMatch_t_outPort_get, _OFDPA_python.ofdpaEgressVlan1FlowMatch_t_outPort_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaEgressVlan1FlowMatch_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaEgressVlan1FlowMatch_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowMatch_t_vlanId_get, _OFDPA_python.ofdpaEgressVlan1FlowMatch_t_vlanId_set)
    __swig_setmethods__["ovid"] = _OFDPA_python.ofdpaEgressVlan1FlowMatch_t_ovid_set
    __swig_getmethods__["ovid"] = _OFDPA_python.ofdpaEgressVlan1FlowMatch_t_ovid_get
    if _newclass:ovid = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowMatch_t_ovid_get, _OFDPA_python.ofdpaEgressVlan1FlowMatch_t_ovid_set)
    def __init__(self): 
        """__init__(ofdpaEgressVlan1FlowMatch_s self) -> ofdpaEgressVlan1FlowMatch_t"""
        this = _OFDPA_python.new_ofdpaEgressVlan1FlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEgressVlan1FlowMatch_t
    __del__ = lambda self : None;
ofdpaEgressVlan1FlowMatch_t_swigregister = _OFDPA_python.ofdpaEgressVlan1FlowMatch_t_swigregister
ofdpaEgressVlan1FlowMatch_t_swigregister(ofdpaEgressVlan1FlowMatch_t)

class ofdpaEgressVlan1FlowEntry_t(_object):
    """Proxy of C ofdpaEgressVlan1FlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEgressVlan1FlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEgressVlan1FlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_gotoTableId_set)
    __swig_setmethods__["setVlanIdAction"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_setVlanIdAction_set
    __swig_getmethods__["setVlanIdAction"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_setVlanIdAction_get
    if _newclass:setVlanIdAction = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowEntry_t_setVlanIdAction_get, _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_setVlanIdAction_set)
    __swig_setmethods__["newVlanId"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newVlanId_set
    __swig_getmethods__["newVlanId"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newVlanId_get
    if _newclass:newVlanId = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newVlanId_get, _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newVlanId_set)
    __swig_setmethods__["pushVlan2Action"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_pushVlan2Action_set
    __swig_getmethods__["pushVlan2Action"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_pushVlan2Action_get
    if _newclass:pushVlan2Action = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowEntry_t_pushVlan2Action_get, _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_pushVlan2Action_set)
    __swig_setmethods__["newTpid2"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newTpid2_set
    __swig_getmethods__["newTpid2"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newTpid2_get
    if _newclass:newTpid2 = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newTpid2_get, _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newTpid2_set)
    __swig_setmethods__["setVlanId2Action"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_setVlanId2Action_set
    __swig_getmethods__["setVlanId2Action"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_setVlanId2Action_get
    if _newclass:setVlanId2Action = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowEntry_t_setVlanId2Action_get, _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_setVlanId2Action_set)
    __swig_setmethods__["newVlanId2"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newVlanId2_set
    __swig_getmethods__["newVlanId2"] = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newVlanId2_get
    if _newclass:newVlanId2 = _swig_property(_OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newVlanId2_get, _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_newVlanId2_set)
    def __init__(self): 
        """__init__(ofdpaEgressVlan1FlowEntry_s self) -> ofdpaEgressVlan1FlowEntry_t"""
        this = _OFDPA_python.new_ofdpaEgressVlan1FlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEgressVlan1FlowEntry_t
    __del__ = lambda self : None;
ofdpaEgressVlan1FlowEntry_t_swigregister = _OFDPA_python.ofdpaEgressVlan1FlowEntry_t_swigregister
ofdpaEgressVlan1FlowEntry_t_swigregister(ofdpaEgressVlan1FlowEntry_t)

class ofdpaEgressMpFlowMatch_t(_object):
    """Proxy of C ofdpaEgressMpFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEgressMpFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEgressMpFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_etherType_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_etherType_set)
    __swig_setmethods__["etherTypeMask"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_etherTypeMask_set
    __swig_getmethods__["etherTypeMask"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_etherTypeMask_get
    if _newclass:etherTypeMask = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_etherTypeMask_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_etherTypeMask_set)
    __swig_setmethods__["oamY1731Mdl"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731Mdl_set
    __swig_getmethods__["oamY1731Mdl"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731Mdl_get
    if _newclass:oamY1731Mdl = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731Mdl_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731Mdl_set)
    __swig_setmethods__["oamY1731MdlMask"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731MdlMask_set
    __swig_getmethods__["oamY1731MdlMask"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731MdlMask_get
    if _newclass:oamY1731MdlMask = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731MdlMask_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731MdlMask_set)
    __swig_setmethods__["oamY1731Opcode"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731Opcode_set
    __swig_getmethods__["oamY1731Opcode"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731Opcode_get
    if _newclass:oamY1731Opcode = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731Opcode_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731Opcode_set)
    __swig_setmethods__["oamY1731OpcodeMask"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731OpcodeMask_set
    __swig_getmethods__["oamY1731OpcodeMask"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731OpcodeMask_get
    if _newclass:oamY1731OpcodeMask = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731OpcodeMask_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_oamY1731OpcodeMask_set)
    __swig_setmethods__["outPort"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_outPort_set
    __swig_getmethods__["outPort"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_outPort_get
    if _newclass:outPort = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_outPort_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_outPort_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_vlanId_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_vlanId_set)
    __swig_setmethods__["vlanIdMask"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_vlanIdMask_set
    __swig_getmethods__["vlanIdMask"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_vlanIdMask_get
    if _newclass:vlanIdMask = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_vlanIdMask_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_vlanIdMask_set)
    __swig_setmethods__["destMac"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_destMac_set
    __swig_getmethods__["destMac"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_destMac_get
    if _newclass:destMac = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_destMac_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_destMac_set)
    __swig_setmethods__["destMacMask"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_destMacMask_set
    __swig_getmethods__["destMacMask"] = _OFDPA_python.ofdpaEgressMpFlowMatch_t_destMacMask_get
    if _newclass:destMacMask = _swig_property(_OFDPA_python.ofdpaEgressMpFlowMatch_t_destMacMask_get, _OFDPA_python.ofdpaEgressMpFlowMatch_t_destMacMask_set)
    def __init__(self): 
        """__init__(ofdpaEgressMpFlowMatch_s self) -> ofdpaEgressMpFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaEgressMpFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEgressMpFlowMatch_t
    __del__ = lambda self : None;
ofdpaEgressMpFlowMatch_t_swigregister = _OFDPA_python.ofdpaEgressMpFlowMatch_t_swigregister
ofdpaEgressMpFlowMatch_t_swigregister(ofdpaEgressMpFlowMatch_t)

class ofdpaEgressMpFlowEntry_t(_object):
    """Proxy of C ofdpaEgressMpFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEgressMpFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEgressMpFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaEgressMpFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaEgressMpFlowEntry_t_match_criteria_set)
    __swig_setmethods__["clearAction"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_clearAction_set
    __swig_getmethods__["clearAction"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_clearAction_get
    if _newclass:clearAction = _swig_property(_OFDPA_python.ofdpaEgressMpFlowEntry_t_clearAction_get, _OFDPA_python.ofdpaEgressMpFlowEntry_t_clearAction_set)
    __swig_setmethods__["lmepIdAction"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_lmepIdAction_set
    __swig_getmethods__["lmepIdAction"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_lmepIdAction_get
    if _newclass:lmepIdAction = _swig_property(_OFDPA_python.ofdpaEgressMpFlowEntry_t_lmepIdAction_get, _OFDPA_python.ofdpaEgressMpFlowEntry_t_lmepIdAction_set)
    __swig_setmethods__["oamSetCounterFieldsAction"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_oamSetCounterFieldsAction_set
    __swig_getmethods__["oamSetCounterFieldsAction"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_oamSetCounterFieldsAction_get
    if _newclass:oamSetCounterFieldsAction = _swig_property(_OFDPA_python.ofdpaEgressMpFlowEntry_t_oamSetCounterFieldsAction_get, _OFDPA_python.ofdpaEgressMpFlowEntry_t_oamSetCounterFieldsAction_set)
    __swig_setmethods__["oamLmRxCountAction"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_oamLmRxCountAction_set
    __swig_getmethods__["oamLmRxCountAction"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_oamLmRxCountAction_get
    if _newclass:oamLmRxCountAction = _swig_property(_OFDPA_python.ofdpaEgressMpFlowEntry_t_oamLmRxCountAction_get, _OFDPA_python.ofdpaEgressMpFlowEntry_t_oamLmRxCountAction_set)
    __swig_setmethods__["checkDropStatusAction"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_checkDropStatusAction_set
    __swig_getmethods__["checkDropStatusAction"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_checkDropStatusAction_get
    if _newclass:checkDropStatusAction = _swig_property(_OFDPA_python.ofdpaEgressMpFlowEntry_t_checkDropStatusAction_get, _OFDPA_python.ofdpaEgressMpFlowEntry_t_checkDropStatusAction_set)
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaEgressMpFlowEntry_t_lmepId_get, _OFDPA_python.ofdpaEgressMpFlowEntry_t_lmepId_set)
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaEgressMpFlowEntry_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaEgressMpFlowEntry_t_outputPort_get, _OFDPA_python.ofdpaEgressMpFlowEntry_t_outputPort_set)
    def __init__(self): 
        """__init__(ofdpaEgressMpFlowEntry_s self) -> ofdpaEgressMpFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaEgressMpFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEgressMpFlowEntry_t
    __del__ = lambda self : None;
ofdpaEgressMpFlowEntry_t_swigregister = _OFDPA_python.ofdpaEgressMpFlowEntry_t_swigregister
ofdpaEgressMpFlowEntry_t_swigregister(ofdpaEgressMpFlowEntry_t)

class ofdpaEgressDscpPcpRemarkFlowMatch_t(_object):
    """Proxy of C ofdpaEgressDscpPcpRemarkFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEgressDscpPcpRemarkFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEgressDscpPcpRemarkFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["etherType"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_etherType_set
    __swig_getmethods__["etherType"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_etherType_get
    if _newclass:etherType = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_etherType_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_etherType_set)
    __swig_setmethods__["etherTypeMask"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_etherTypeMask_set
    __swig_getmethods__["etherTypeMask"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_etherTypeMask_get
    if _newclass:etherTypeMask = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_etherTypeMask_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_etherTypeMask_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_trafficClass_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_trafficClass_set)
    __swig_setmethods__["color"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_color_set
    __swig_getmethods__["color"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_color_get
    if _newclass:color = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_color_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_color_set)
    __swig_setmethods__["outPort"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_outPort_set
    __swig_getmethods__["outPort"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_outPort_get
    if _newclass:outPort = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_outPort_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_outPort_set)
    def __init__(self): 
        """__init__(ofdpaEgressDscpPcpRemarkFlowMatch_s self) -> ofdpaEgressDscpPcpRemarkFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaEgressDscpPcpRemarkFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEgressDscpPcpRemarkFlowMatch_t
    __del__ = lambda self : None;
ofdpaEgressDscpPcpRemarkFlowMatch_t_swigregister = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowMatch_t_swigregister
ofdpaEgressDscpPcpRemarkFlowMatch_t_swigregister(ofdpaEgressDscpPcpRemarkFlowMatch_t)

class ofdpaEgressDscpPcpRemarkFlowEntry_t(_object):
    """Proxy of C ofdpaEgressDscpPcpRemarkFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEgressDscpPcpRemarkFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEgressDscpPcpRemarkFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_match_criteria_set)
    __swig_setmethods__["gotoTableId"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_gotoTableId_set
    __swig_getmethods__["gotoTableId"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_gotoTableId_get
    if _newclass:gotoTableId = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_gotoTableId_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_gotoTableId_set)
    __swig_setmethods__["vlanPcpAction"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanPcpAction_set
    __swig_getmethods__["vlanPcpAction"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanPcpAction_get
    if _newclass:vlanPcpAction = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanPcpAction_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanPcpAction_set)
    __swig_setmethods__["vlanPcp"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanPcp_set
    __swig_getmethods__["vlanPcp"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanPcp_get
    if _newclass:vlanPcp = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanPcp_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanPcp_set)
    __swig_setmethods__["vlanDeiAction"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanDeiAction_set
    __swig_getmethods__["vlanDeiAction"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanDeiAction_get
    if _newclass:vlanDeiAction = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanDeiAction_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanDeiAction_set)
    __swig_setmethods__["vlanDei"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanDei_set
    __swig_getmethods__["vlanDei"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanDei_get
    if _newclass:vlanDei = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanDei_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_vlanDei_set)
    __swig_setmethods__["dscpAction"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_dscpAction_set
    __swig_getmethods__["dscpAction"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_dscpAction_get
    if _newclass:dscpAction = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_dscpAction_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_dscpAction_set)
    __swig_setmethods__["dscp"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_dscp_set
    __swig_getmethods__["dscp"] = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_dscp_get
    if _newclass:dscp = _swig_property(_OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_dscp_get, _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_dscp_set)
    def __init__(self): 
        """__init__(ofdpaEgressDscpPcpRemarkFlowEntry_s self) -> ofdpaEgressDscpPcpRemarkFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaEgressDscpPcpRemarkFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEgressDscpPcpRemarkFlowEntry_t
    __del__ = lambda self : None;
ofdpaEgressDscpPcpRemarkFlowEntry_t_swigregister = _OFDPA_python.ofdpaEgressDscpPcpRemarkFlowEntry_t_swigregister
ofdpaEgressDscpPcpRemarkFlowEntry_t_swigregister(ofdpaEgressDscpPcpRemarkFlowEntry_t)

class ofdpaEgressTpidFlowMatch_t(_object):
    """Proxy of C ofdpaEgressTpidFlowMatch_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEgressTpidFlowMatch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEgressTpidFlowMatch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["outPort"] = _OFDPA_python.ofdpaEgressTpidFlowMatch_t_outPort_set
    __swig_getmethods__["outPort"] = _OFDPA_python.ofdpaEgressTpidFlowMatch_t_outPort_get
    if _newclass:outPort = _swig_property(_OFDPA_python.ofdpaEgressTpidFlowMatch_t_outPort_get, _OFDPA_python.ofdpaEgressTpidFlowMatch_t_outPort_set)
    def __init__(self): 
        """__init__(ofdpaEgressTpidFlowMatch_s self) -> ofdpaEgressTpidFlowMatch_t"""
        this = _OFDPA_python.new_ofdpaEgressTpidFlowMatch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEgressTpidFlowMatch_t
    __del__ = lambda self : None;
ofdpaEgressTpidFlowMatch_t_swigregister = _OFDPA_python.ofdpaEgressTpidFlowMatch_t_swigregister
ofdpaEgressTpidFlowMatch_t_swigregister(ofdpaEgressTpidFlowMatch_t)

class ofdpaEgressTpidFlowEntry_t(_object):
    """Proxy of C ofdpaEgressTpidFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEgressTpidFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEgressTpidFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["match_criteria"] = _OFDPA_python.ofdpaEgressTpidFlowEntry_t_match_criteria_set
    __swig_getmethods__["match_criteria"] = _OFDPA_python.ofdpaEgressTpidFlowEntry_t_match_criteria_get
    if _newclass:match_criteria = _swig_property(_OFDPA_python.ofdpaEgressTpidFlowEntry_t_match_criteria_get, _OFDPA_python.ofdpaEgressTpidFlowEntry_t_match_criteria_set)
    __swig_setmethods__["newTpid"] = _OFDPA_python.ofdpaEgressTpidFlowEntry_t_newTpid_set
    __swig_getmethods__["newTpid"] = _OFDPA_python.ofdpaEgressTpidFlowEntry_t_newTpid_get
    if _newclass:newTpid = _swig_property(_OFDPA_python.ofdpaEgressTpidFlowEntry_t_newTpid_get, _OFDPA_python.ofdpaEgressTpidFlowEntry_t_newTpid_set)
    def __init__(self): 
        """__init__(ofdpaEgressTpidFlowEntry_s self) -> ofdpaEgressTpidFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaEgressTpidFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEgressTpidFlowEntry_t
    __del__ = lambda self : None;
ofdpaEgressTpidFlowEntry_t_swigregister = _OFDPA_python.ofdpaEgressTpidFlowEntry_t_swigregister
ofdpaEgressTpidFlowEntry_t_swigregister(ofdpaEgressTpidFlowEntry_t)

class ofdpaFlowEntry_t(_object):
    """Proxy of C ofdpaFlowEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaFlowEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaFlowEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tableId"] = _OFDPA_python.ofdpaFlowEntry_t_tableId_set
    __swig_getmethods__["tableId"] = _OFDPA_python.ofdpaFlowEntry_t_tableId_get
    if _newclass:tableId = _swig_property(_OFDPA_python.ofdpaFlowEntry_t_tableId_get, _OFDPA_python.ofdpaFlowEntry_t_tableId_set)
    __swig_setmethods__["priority"] = _OFDPA_python.ofdpaFlowEntry_t_priority_set
    __swig_getmethods__["priority"] = _OFDPA_python.ofdpaFlowEntry_t_priority_get
    if _newclass:priority = _swig_property(_OFDPA_python.ofdpaFlowEntry_t_priority_get, _OFDPA_python.ofdpaFlowEntry_t_priority_set)
    __swig_getmethods__["flowData"] = _OFDPA_python.ofdpaFlowEntry_t_flowData_get
    if _newclass:flowData = _swig_property(_OFDPA_python.ofdpaFlowEntry_t_flowData_get)
    __swig_setmethods__["hard_time"] = _OFDPA_python.ofdpaFlowEntry_t_hard_time_set
    __swig_getmethods__["hard_time"] = _OFDPA_python.ofdpaFlowEntry_t_hard_time_get
    if _newclass:hard_time = _swig_property(_OFDPA_python.ofdpaFlowEntry_t_hard_time_get, _OFDPA_python.ofdpaFlowEntry_t_hard_time_set)
    __swig_setmethods__["idle_time"] = _OFDPA_python.ofdpaFlowEntry_t_idle_time_set
    __swig_getmethods__["idle_time"] = _OFDPA_python.ofdpaFlowEntry_t_idle_time_get
    if _newclass:idle_time = _swig_property(_OFDPA_python.ofdpaFlowEntry_t_idle_time_get, _OFDPA_python.ofdpaFlowEntry_t_idle_time_set)
    __swig_setmethods__["cookie"] = _OFDPA_python.ofdpaFlowEntry_t_cookie_set
    __swig_getmethods__["cookie"] = _OFDPA_python.ofdpaFlowEntry_t_cookie_get
    if _newclass:cookie = _swig_property(_OFDPA_python.ofdpaFlowEntry_t_cookie_get, _OFDPA_python.ofdpaFlowEntry_t_cookie_set)
    def __init__(self): 
        """__init__(ofdpaFlowEntry_s self) -> ofdpaFlowEntry_t"""
        this = _OFDPA_python.new_ofdpaFlowEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaFlowEntry_t
    __del__ = lambda self : None;
ofdpaFlowEntry_t_swigregister = _OFDPA_python.ofdpaFlowEntry_t_swigregister
ofdpaFlowEntry_t_swigregister(ofdpaFlowEntry_t)

class ofdpaFlowEntry_s_flowData(_object):
    """Proxy of C ofdpaFlowEntry_s_flowData struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaFlowEntry_s_flowData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaFlowEntry_s_flowData, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ingressPortFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_ingressPortFlowEntry_set
    __swig_getmethods__["ingressPortFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_ingressPortFlowEntry_get
    if _newclass:ingressPortFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_ingressPortFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_ingressPortFlowEntry_set)
    __swig_setmethods__["dscpTrustFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_dscpTrustFlowEntry_set
    __swig_getmethods__["dscpTrustFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_dscpTrustFlowEntry_get
    if _newclass:dscpTrustFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_dscpTrustFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_dscpTrustFlowEntry_set)
    __swig_setmethods__["pcpTrustFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_pcpTrustFlowEntry_set
    __swig_getmethods__["pcpTrustFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_pcpTrustFlowEntry_get
    if _newclass:pcpTrustFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_pcpTrustFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_pcpTrustFlowEntry_set)
    __swig_setmethods__["injectedOamFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_injectedOamFlowEntry_set
    __swig_getmethods__["injectedOamFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_injectedOamFlowEntry_get
    if _newclass:injectedOamFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_injectedOamFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_injectedOamFlowEntry_set)
    __swig_setmethods__["vlanFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_vlanFlowEntry_set
    __swig_getmethods__["vlanFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_vlanFlowEntry_get
    if _newclass:vlanFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_vlanFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_vlanFlowEntry_set)
    __swig_setmethods__["vlan1FlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_vlan1FlowEntry_set
    __swig_getmethods__["vlan1FlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_vlan1FlowEntry_get
    if _newclass:vlan1FlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_vlan1FlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_vlan1FlowEntry_set)
    __swig_setmethods__["mpFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_mpFlowEntry_set
    __swig_getmethods__["mpFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_mpFlowEntry_get
    if _newclass:mpFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_mpFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_mpFlowEntry_set)
    __swig_setmethods__["mplsL2PortFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_mplsL2PortFlowEntry_set
    __swig_getmethods__["mplsL2PortFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_mplsL2PortFlowEntry_get
    if _newclass:mplsL2PortFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_mplsL2PortFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_mplsL2PortFlowEntry_set)
    __swig_setmethods__["l2PolicerFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_l2PolicerFlowEntry_set
    __swig_getmethods__["l2PolicerFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_l2PolicerFlowEntry_get
    if _newclass:l2PolicerFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_l2PolicerFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_l2PolicerFlowEntry_set)
    __swig_setmethods__["l2PolicerActionsFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_l2PolicerActionsFlowEntry_set
    __swig_getmethods__["l2PolicerActionsFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_l2PolicerActionsFlowEntry_get
    if _newclass:l2PolicerActionsFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_l2PolicerActionsFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_l2PolicerActionsFlowEntry_set)
    __swig_setmethods__["terminationMacFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_terminationMacFlowEntry_set
    __swig_getmethods__["terminationMacFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_terminationMacFlowEntry_get
    if _newclass:terminationMacFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_terminationMacFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_terminationMacFlowEntry_set)
    __swig_setmethods__["bridgingFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_bridgingFlowEntry_set
    __swig_getmethods__["bridgingFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_bridgingFlowEntry_get
    if _newclass:bridgingFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_bridgingFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_bridgingFlowEntry_set)
    __swig_setmethods__["unicastRoutingFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_unicastRoutingFlowEntry_set
    __swig_getmethods__["unicastRoutingFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_unicastRoutingFlowEntry_get
    if _newclass:unicastRoutingFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_unicastRoutingFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_unicastRoutingFlowEntry_set)
    __swig_setmethods__["multicastRoutingFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_multicastRoutingFlowEntry_set
    __swig_getmethods__["multicastRoutingFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_multicastRoutingFlowEntry_get
    if _newclass:multicastRoutingFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_multicastRoutingFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_multicastRoutingFlowEntry_set)
    __swig_setmethods__["mplsFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_mplsFlowEntry_set
    __swig_getmethods__["mplsFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_mplsFlowEntry_get
    if _newclass:mplsFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_mplsFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_mplsFlowEntry_set)
    __swig_setmethods__["mplsMpFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_mplsMpFlowEntry_set
    __swig_getmethods__["mplsMpFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_mplsMpFlowEntry_get
    if _newclass:mplsMpFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_mplsMpFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_mplsMpFlowEntry_set)
    __swig_setmethods__["policyAclFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_policyAclFlowEntry_set
    __swig_getmethods__["policyAclFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_policyAclFlowEntry_get
    if _newclass:policyAclFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_policyAclFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_policyAclFlowEntry_set)
    __swig_setmethods__["colorActionsFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_colorActionsFlowEntry_set
    __swig_getmethods__["colorActionsFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_colorActionsFlowEntry_get
    if _newclass:colorActionsFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_colorActionsFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_colorActionsFlowEntry_set)
    __swig_setmethods__["egressVlanFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_egressVlanFlowEntry_set
    __swig_getmethods__["egressVlanFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_egressVlanFlowEntry_get
    if _newclass:egressVlanFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_egressVlanFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_egressVlanFlowEntry_set)
    __swig_setmethods__["egressVlan1FlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_egressVlan1FlowEntry_set
    __swig_getmethods__["egressVlan1FlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_egressVlan1FlowEntry_get
    if _newclass:egressVlan1FlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_egressVlan1FlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_egressVlan1FlowEntry_set)
    __swig_setmethods__["egressMpFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_egressMpFlowEntry_set
    __swig_getmethods__["egressMpFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_egressMpFlowEntry_get
    if _newclass:egressMpFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_egressMpFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_egressMpFlowEntry_set)
    __swig_setmethods__["egressDscpPcpRemarkFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_egressDscpPcpRemarkFlowEntry_set
    __swig_getmethods__["egressDscpPcpRemarkFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_egressDscpPcpRemarkFlowEntry_get
    if _newclass:egressDscpPcpRemarkFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_egressDscpPcpRemarkFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_egressDscpPcpRemarkFlowEntry_set)
    __swig_setmethods__["egressTpidFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_egressTpidFlowEntry_set
    __swig_getmethods__["egressTpidFlowEntry"] = _OFDPA_python.ofdpaFlowEntry_s_flowData_egressTpidFlowEntry_get
    if _newclass:egressTpidFlowEntry = _swig_property(_OFDPA_python.ofdpaFlowEntry_s_flowData_egressTpidFlowEntry_get, _OFDPA_python.ofdpaFlowEntry_s_flowData_egressTpidFlowEntry_set)
    def __init__(self): 
        """__init__(ofdpaFlowEntry_s_flowData self) -> ofdpaFlowEntry_s_flowData"""
        this = _OFDPA_python.new_ofdpaFlowEntry_s_flowData()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaFlowEntry_s_flowData
    __del__ = lambda self : None;
ofdpaFlowEntry_s_flowData_swigregister = _OFDPA_python.ofdpaFlowEntry_s_flowData_swigregister
ofdpaFlowEntry_s_flowData_swigregister(ofdpaFlowEntry_s_flowData)

class ofdpaFlowEntryStats_t(_object):
    """Proxy of C ofdpaFlowEntryStats_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaFlowEntryStats_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaFlowEntryStats_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["durationSec"] = _OFDPA_python.ofdpaFlowEntryStats_t_durationSec_set
    __swig_getmethods__["durationSec"] = _OFDPA_python.ofdpaFlowEntryStats_t_durationSec_get
    if _newclass:durationSec = _swig_property(_OFDPA_python.ofdpaFlowEntryStats_t_durationSec_get, _OFDPA_python.ofdpaFlowEntryStats_t_durationSec_set)
    __swig_setmethods__["receivedPackets"] = _OFDPA_python.ofdpaFlowEntryStats_t_receivedPackets_set
    __swig_getmethods__["receivedPackets"] = _OFDPA_python.ofdpaFlowEntryStats_t_receivedPackets_get
    if _newclass:receivedPackets = _swig_property(_OFDPA_python.ofdpaFlowEntryStats_t_receivedPackets_get, _OFDPA_python.ofdpaFlowEntryStats_t_receivedPackets_set)
    __swig_setmethods__["receivedBytes"] = _OFDPA_python.ofdpaFlowEntryStats_t_receivedBytes_set
    __swig_getmethods__["receivedBytes"] = _OFDPA_python.ofdpaFlowEntryStats_t_receivedBytes_get
    if _newclass:receivedBytes = _swig_property(_OFDPA_python.ofdpaFlowEntryStats_t_receivedBytes_get, _OFDPA_python.ofdpaFlowEntryStats_t_receivedBytes_set)
    def __init__(self): 
        """__init__(ofdpaFlowEntryStats_s self) -> ofdpaFlowEntryStats_t"""
        this = _OFDPA_python.new_ofdpaFlowEntryStats_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaFlowEntryStats_t
    __del__ = lambda self : None;
ofdpaFlowEntryStats_t_swigregister = _OFDPA_python.ofdpaFlowEntryStats_t_swigregister
ofdpaFlowEntryStats_t_swigregister(ofdpaFlowEntryStats_t)

OFDPA_GROUP_ENTRY_TYPE_L2_INTERFACE = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_L2_INTERFACE
OFDPA_GROUP_ENTRY_TYPE_L2_REWRITE = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_L2_REWRITE
OFDPA_GROUP_ENTRY_TYPE_L3_UNICAST = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_L3_UNICAST
OFDPA_GROUP_ENTRY_TYPE_L2_MULTICAST = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_L2_MULTICAST
OFDPA_GROUP_ENTRY_TYPE_L2_FLOOD = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_L2_FLOOD
OFDPA_GROUP_ENTRY_TYPE_L3_INTERFACE = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_L3_INTERFACE
OFDPA_GROUP_ENTRY_TYPE_L3_MULTICAST = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_L3_MULTICAST
OFDPA_GROUP_ENTRY_TYPE_L3_ECMP = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_L3_ECMP
OFDPA_GROUP_ENTRY_TYPE_L2_OVERLAY = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_L2_OVERLAY
OFDPA_GROUP_ENTRY_TYPE_MPLS_LABEL = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_MPLS_LABEL
OFDPA_GROUP_ENTRY_TYPE_MPLS_FORWARDING = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_MPLS_FORWARDING
OFDPA_GROUP_ENTRY_TYPE_L2_UNFILTERED_INTERFACE = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_L2_UNFILTERED_INTERFACE
OFDPA_GROUP_ENTRY_TYPE_LAST = _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_LAST
OFDPA_L2_OVERLAY_FLOOD_UNICAST_TUNNEL = _OFDPA_python.OFDPA_L2_OVERLAY_FLOOD_UNICAST_TUNNEL
OFDPA_L2_OVERLAY_FLOOD_MULTICAST_TUNNEL = _OFDPA_python.OFDPA_L2_OVERLAY_FLOOD_MULTICAST_TUNNEL
OFDPA_L2_OVERLAY_MULTICAST_UNICAST_TUNNEL = _OFDPA_python.OFDPA_L2_OVERLAY_MULTICAST_UNICAST_TUNNEL
OFDPA_L2_OVERLAY_MULTICAST_MULTICAST_TUNNEL = _OFDPA_python.OFDPA_L2_OVERLAY_MULTICAST_MULTICAST_TUNNEL
OFDPA_MPLS_INTERFACE = _OFDPA_python.OFDPA_MPLS_INTERFACE
OFDPA_MPLS_L2_VPN_LABEL = _OFDPA_python.OFDPA_MPLS_L2_VPN_LABEL
OFDPA_MPLS_L3_VPN_LABEL = _OFDPA_python.OFDPA_MPLS_L3_VPN_LABEL
OFDPA_MPLS_TUNNEL_LABEL1 = _OFDPA_python.OFDPA_MPLS_TUNNEL_LABEL1
OFDPA_MPLS_TUNNEL_LABEL2 = _OFDPA_python.OFDPA_MPLS_TUNNEL_LABEL2
OFDPA_MPLS_SWAP_LABEL = _OFDPA_python.OFDPA_MPLS_SWAP_LABEL
OFDPA_MPLS_L2_FLOOD = _OFDPA_python.OFDPA_MPLS_L2_FLOOD
OFDPA_MPLS_L2_MULTICAST = _OFDPA_python.OFDPA_MPLS_L2_MULTICAST
OFDPA_MPLS_L2_LOCAL_FLOOD = _OFDPA_python.OFDPA_MPLS_L2_LOCAL_FLOOD
OFDPA_MPLS_L2_LOCAL_MULTICAST = _OFDPA_python.OFDPA_MPLS_L2_LOCAL_MULTICAST
OFDPA_MPLS_L2_FLOOD_SPLIT_HORIZON = _OFDPA_python.OFDPA_MPLS_L2_FLOOD_SPLIT_HORIZON
OFDPA_MPLS_L2_MULTICAST_SPLIT_HORIZON = _OFDPA_python.OFDPA_MPLS_L2_MULTICAST_SPLIT_HORIZON
OFDPA_MPLS_FAST_FAILOVER = _OFDPA_python.OFDPA_MPLS_FAST_FAILOVER
OFDPA_MPLS_1_1_HEAD_END_PROTECT = _OFDPA_python.OFDPA_MPLS_1_1_HEAD_END_PROTECT
OFDPA_MPLS_ECMP = _OFDPA_python.OFDPA_MPLS_ECMP
OFDPA_MPLS_L2_TAG = _OFDPA_python.OFDPA_MPLS_L2_TAG
class ofdpaGroupEntry_t(_object):
    """Proxy of C ofdpaGroupEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaGroupEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaGroupEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["groupId"] = _OFDPA_python.ofdpaGroupEntry_t_groupId_set
    __swig_getmethods__["groupId"] = _OFDPA_python.ofdpaGroupEntry_t_groupId_get
    if _newclass:groupId = _swig_property(_OFDPA_python.ofdpaGroupEntry_t_groupId_get, _OFDPA_python.ofdpaGroupEntry_t_groupId_set)
    def __init__(self): 
        """__init__(ofdpaGroupEntry_s self) -> ofdpaGroupEntry_t"""
        this = _OFDPA_python.new_ofdpaGroupEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaGroupEntry_t
    __del__ = lambda self : None;
ofdpaGroupEntry_t_swigregister = _OFDPA_python.ofdpaGroupEntry_t_swigregister
ofdpaGroupEntry_t_swigregister(ofdpaGroupEntry_t)

class ofdpaGroupEntryStats_t(_object):
    """Proxy of C ofdpaGroupEntryStats_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaGroupEntryStats_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaGroupEntryStats_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaGroupEntryStats_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaGroupEntryStats_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaGroupEntryStats_t_refCount_get, _OFDPA_python.ofdpaGroupEntryStats_t_refCount_set)
    __swig_setmethods__["duration"] = _OFDPA_python.ofdpaGroupEntryStats_t_duration_set
    __swig_getmethods__["duration"] = _OFDPA_python.ofdpaGroupEntryStats_t_duration_get
    if _newclass:duration = _swig_property(_OFDPA_python.ofdpaGroupEntryStats_t_duration_get, _OFDPA_python.ofdpaGroupEntryStats_t_duration_set)
    __swig_setmethods__["bucketCount"] = _OFDPA_python.ofdpaGroupEntryStats_t_bucketCount_set
    __swig_getmethods__["bucketCount"] = _OFDPA_python.ofdpaGroupEntryStats_t_bucketCount_get
    if _newclass:bucketCount = _swig_property(_OFDPA_python.ofdpaGroupEntryStats_t_bucketCount_get, _OFDPA_python.ofdpaGroupEntryStats_t_bucketCount_set)
    def __init__(self): 
        """__init__(ofdpaGroupEntryStats_s self) -> ofdpaGroupEntryStats_t"""
        this = _OFDPA_python.new_ofdpaGroupEntryStats_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaGroupEntryStats_t
    __del__ = lambda self : None;
ofdpaGroupEntryStats_t_swigregister = _OFDPA_python.ofdpaGroupEntryStats_t_swigregister
ofdpaGroupEntryStats_t_swigregister(ofdpaGroupEntryStats_t)

class ofdpaL2InterfaceGroupBucketData_t(_object):
    """Proxy of C ofdpaL2InterfaceGroupBucketData_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaL2InterfaceGroupBucketData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaL2InterfaceGroupBucketData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_outputPort_get, _OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_outputPort_set)
    __swig_setmethods__["popVlanTag"] = _OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_popVlanTag_set
    __swig_getmethods__["popVlanTag"] = _OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_popVlanTag_get
    if _newclass:popVlanTag = _swig_property(_OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_popVlanTag_get, _OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_popVlanTag_set)
    __swig_setmethods__["allowVlanTranslation"] = _OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_allowVlanTranslation_set
    __swig_getmethods__["allowVlanTranslation"] = _OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_allowVlanTranslation_get
    if _newclass:allowVlanTranslation = _swig_property(_OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_allowVlanTranslation_get, _OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_allowVlanTranslation_set)
    def __init__(self): 
        """__init__(ofdpaL2InterfaceGroupBucketData_s self) -> ofdpaL2InterfaceGroupBucketData_t"""
        this = _OFDPA_python.new_ofdpaL2InterfaceGroupBucketData_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaL2InterfaceGroupBucketData_t
    __del__ = lambda self : None;
ofdpaL2InterfaceGroupBucketData_t_swigregister = _OFDPA_python.ofdpaL2InterfaceGroupBucketData_t_swigregister
ofdpaL2InterfaceGroupBucketData_t_swigregister(ofdpaL2InterfaceGroupBucketData_t)

class ofdpaL3InterfaceGroupBucketData_t(_object):
    """Proxy of C ofdpaL3InterfaceGroupBucketData_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaL3InterfaceGroupBucketData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaL3InterfaceGroupBucketData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaL3InterfaceGroupBucketData_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaL3InterfaceGroupBucketData_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaL3InterfaceGroupBucketData_t_vlanId_get, _OFDPA_python.ofdpaL3InterfaceGroupBucketData_t_vlanId_set)
    __swig_setmethods__["srcMac"] = _OFDPA_python.ofdpaL3InterfaceGroupBucketData_t_srcMac_set
    __swig_getmethods__["srcMac"] = _OFDPA_python.ofdpaL3InterfaceGroupBucketData_t_srcMac_get
    if _newclass:srcMac = _swig_property(_OFDPA_python.ofdpaL3InterfaceGroupBucketData_t_srcMac_get, _OFDPA_python.ofdpaL3InterfaceGroupBucketData_t_srcMac_set)
    def __init__(self): 
        """__init__(ofdpaL3InterfaceGroupBucketData_s self) -> ofdpaL3InterfaceGroupBucketData_t"""
        this = _OFDPA_python.new_ofdpaL3InterfaceGroupBucketData_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaL3InterfaceGroupBucketData_t
    __del__ = lambda self : None;
ofdpaL3InterfaceGroupBucketData_t_swigregister = _OFDPA_python.ofdpaL3InterfaceGroupBucketData_t_swigregister
ofdpaL3InterfaceGroupBucketData_t_swigregister(ofdpaL3InterfaceGroupBucketData_t)

class ofdpaL3UnicastGroupBucketData_t(_object):
    """Proxy of C ofdpaL3UnicastGroupBucketData_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaL3UnicastGroupBucketData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaL3UnicastGroupBucketData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["srcMac"] = _OFDPA_python.ofdpaL3UnicastGroupBucketData_t_srcMac_set
    __swig_getmethods__["srcMac"] = _OFDPA_python.ofdpaL3UnicastGroupBucketData_t_srcMac_get
    if _newclass:srcMac = _swig_property(_OFDPA_python.ofdpaL3UnicastGroupBucketData_t_srcMac_get, _OFDPA_python.ofdpaL3UnicastGroupBucketData_t_srcMac_set)
    __swig_setmethods__["dstMac"] = _OFDPA_python.ofdpaL3UnicastGroupBucketData_t_dstMac_set
    __swig_getmethods__["dstMac"] = _OFDPA_python.ofdpaL3UnicastGroupBucketData_t_dstMac_get
    if _newclass:dstMac = _swig_property(_OFDPA_python.ofdpaL3UnicastGroupBucketData_t_dstMac_get, _OFDPA_python.ofdpaL3UnicastGroupBucketData_t_dstMac_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaL3UnicastGroupBucketData_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaL3UnicastGroupBucketData_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaL3UnicastGroupBucketData_t_vlanId_get, _OFDPA_python.ofdpaL3UnicastGroupBucketData_t_vlanId_set)
    def __init__(self): 
        """__init__(ofdpaL3UnicastGroupBucketData_s self) -> ofdpaL3UnicastGroupBucketData_t"""
        this = _OFDPA_python.new_ofdpaL3UnicastGroupBucketData_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaL3UnicastGroupBucketData_t
    __del__ = lambda self : None;
ofdpaL3UnicastGroupBucketData_t_swigregister = _OFDPA_python.ofdpaL3UnicastGroupBucketData_t_swigregister
ofdpaL3UnicastGroupBucketData_t_swigregister(ofdpaL3UnicastGroupBucketData_t)

class ofdpaL2OverlayGroupBucketData_t(_object):
    """Proxy of C ofdpaL2OverlayGroupBucketData_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaL2OverlayGroupBucketData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaL2OverlayGroupBucketData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaL2OverlayGroupBucketData_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaL2OverlayGroupBucketData_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaL2OverlayGroupBucketData_t_outputPort_get, _OFDPA_python.ofdpaL2OverlayGroupBucketData_t_outputPort_set)
    def __init__(self): 
        """__init__(ofdpaL2OverlayGroupBucketData_s self) -> ofdpaL2OverlayGroupBucketData_t"""
        this = _OFDPA_python.new_ofdpaL2OverlayGroupBucketData_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaL2OverlayGroupBucketData_t
    __del__ = lambda self : None;
ofdpaL2OverlayGroupBucketData_t_swigregister = _OFDPA_python.ofdpaL2OverlayGroupBucketData_t_swigregister
ofdpaL2OverlayGroupBucketData_t_swigregister(ofdpaL2OverlayGroupBucketData_t)

class ofdpaL2RewriteGroupBucketData_t(_object):
    """Proxy of C ofdpaL2RewriteGroupBucketData_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaL2RewriteGroupBucketData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaL2RewriteGroupBucketData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["srcMac"] = _OFDPA_python.ofdpaL2RewriteGroupBucketData_t_srcMac_set
    __swig_getmethods__["srcMac"] = _OFDPA_python.ofdpaL2RewriteGroupBucketData_t_srcMac_get
    if _newclass:srcMac = _swig_property(_OFDPA_python.ofdpaL2RewriteGroupBucketData_t_srcMac_get, _OFDPA_python.ofdpaL2RewriteGroupBucketData_t_srcMac_set)
    __swig_setmethods__["dstMac"] = _OFDPA_python.ofdpaL2RewriteGroupBucketData_t_dstMac_set
    __swig_getmethods__["dstMac"] = _OFDPA_python.ofdpaL2RewriteGroupBucketData_t_dstMac_get
    if _newclass:dstMac = _swig_property(_OFDPA_python.ofdpaL2RewriteGroupBucketData_t_dstMac_get, _OFDPA_python.ofdpaL2RewriteGroupBucketData_t_dstMac_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaL2RewriteGroupBucketData_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaL2RewriteGroupBucketData_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaL2RewriteGroupBucketData_t_vlanId_get, _OFDPA_python.ofdpaL2RewriteGroupBucketData_t_vlanId_set)
    def __init__(self): 
        """__init__(ofdpaL2RewriteGroupBucketData_s self) -> ofdpaL2RewriteGroupBucketData_t"""
        this = _OFDPA_python.new_ofdpaL2RewriteGroupBucketData_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaL2RewriteGroupBucketData_t
    __del__ = lambda self : None;
ofdpaL2RewriteGroupBucketData_t_swigregister = _OFDPA_python.ofdpaL2RewriteGroupBucketData_t_swigregister
ofdpaL2RewriteGroupBucketData_t_swigregister(ofdpaL2RewriteGroupBucketData_t)

class ofdpaMPLSInterfaceGroupBucketData_t(_object):
    """Proxy of C ofdpaMPLSInterfaceGroupBucketData_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMPLSInterfaceGroupBucketData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMPLSInterfaceGroupBucketData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["oamLmTxCountAction"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_oamLmTxCountAction_set
    __swig_getmethods__["oamLmTxCountAction"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_oamLmTxCountAction_get
    if _newclass:oamLmTxCountAction = _swig_property(_OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_oamLmTxCountAction_get, _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_oamLmTxCountAction_set)
    __swig_setmethods__["srcMac"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_srcMac_set
    __swig_getmethods__["srcMac"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_srcMac_get
    if _newclass:srcMac = _swig_property(_OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_srcMac_get, _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_srcMac_set)
    __swig_setmethods__["dstMac"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_dstMac_set
    __swig_getmethods__["dstMac"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_dstMac_get
    if _newclass:dstMac = _swig_property(_OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_dstMac_get, _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_dstMac_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_vlanId_get, _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_vlanId_set)
    __swig_setmethods__["lmepIdAction"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_lmepIdAction_set
    __swig_getmethods__["lmepIdAction"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_lmepIdAction_get
    if _newclass:lmepIdAction = _swig_property(_OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_lmepIdAction_get, _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_lmepIdAction_set)
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_lmepId_get, _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_lmepId_set)
    def __init__(self): 
        """__init__(ofdpaMPLSInterfaceGroupBucketData_s self) -> ofdpaMPLSInterfaceGroupBucketData_t"""
        this = _OFDPA_python.new_ofdpaMPLSInterfaceGroupBucketData_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMPLSInterfaceGroupBucketData_t
    __del__ = lambda self : None;
ofdpaMPLSInterfaceGroupBucketData_t_swigregister = _OFDPA_python.ofdpaMPLSInterfaceGroupBucketData_t_swigregister
ofdpaMPLSInterfaceGroupBucketData_t_swigregister(ofdpaMPLSInterfaceGroupBucketData_t)

class ofdpaMPLSLabelGroupBucketData_t(_object):
    """Proxy of C ofdpaMPLSLabelGroupBucketData_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMPLSLabelGroupBucketData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMPLSLabelGroupBucketData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pushL2Hdr"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushL2Hdr_set
    __swig_getmethods__["pushL2Hdr"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushL2Hdr_get
    if _newclass:pushL2Hdr = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushL2Hdr_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushL2Hdr_set)
    __swig_setmethods__["pushVlan"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushVlan_set
    __swig_getmethods__["pushVlan"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushVlan_get
    if _newclass:pushVlan = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushVlan_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushVlan_set)
    __swig_setmethods__["newTpid"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_newTpid_set
    __swig_getmethods__["newTpid"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_newTpid_get
    if _newclass:newTpid = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_newTpid_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_newTpid_set)
    __swig_setmethods__["pushMplsHdr"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushMplsHdr_set
    __swig_getmethods__["pushMplsHdr"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushMplsHdr_get
    if _newclass:pushMplsHdr = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushMplsHdr_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushMplsHdr_set)
    __swig_setmethods__["mplsEtherType"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEtherType_set
    __swig_getmethods__["mplsEtherType"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEtherType_get
    if _newclass:mplsEtherType = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEtherType_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEtherType_set)
    __swig_setmethods__["pushCW"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushCW_set
    __swig_getmethods__["pushCW"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushCW_get
    if _newclass:pushCW = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushCW_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_pushCW_set)
    __swig_setmethods__["mplsLabel"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsLabel_set
    __swig_getmethods__["mplsLabel"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsLabel_get
    if _newclass:mplsLabel = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsLabel_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsLabel_set)
    __swig_setmethods__["mplsBOS"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsBOS_set
    __swig_getmethods__["mplsBOS"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsBOS_get
    if _newclass:mplsBOS = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsBOS_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsBOS_set)
    __swig_setmethods__["mplsEXPAction"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEXPAction_set
    __swig_getmethods__["mplsEXPAction"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEXPAction_get
    if _newclass:mplsEXPAction = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEXPAction_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEXPAction_set)
    __swig_setmethods__["mplsEXP"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEXP_set
    __swig_getmethods__["mplsEXP"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEXP_get
    if _newclass:mplsEXP = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEXP_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsEXP_set)
    __swig_setmethods__["mplsCopyEXPOutwards"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsCopyEXPOutwards_set
    __swig_getmethods__["mplsCopyEXPOutwards"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsCopyEXPOutwards_get
    if _newclass:mplsCopyEXPOutwards = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsCopyEXPOutwards_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsCopyEXPOutwards_set)
    __swig_setmethods__["remarkTableIndexAction"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_remarkTableIndexAction_set
    __swig_getmethods__["remarkTableIndexAction"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_remarkTableIndexAction_get
    if _newclass:remarkTableIndexAction = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_remarkTableIndexAction_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_remarkTableIndexAction_set)
    __swig_setmethods__["remarkTableIndex"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_remarkTableIndex_set
    __swig_getmethods__["remarkTableIndex"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_remarkTableIndex_get
    if _newclass:remarkTableIndex = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_remarkTableIndex_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_remarkTableIndex_set)
    __swig_setmethods__["mplsTTLAction"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsTTLAction_set
    __swig_getmethods__["mplsTTLAction"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsTTLAction_get
    if _newclass:mplsTTLAction = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsTTLAction_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsTTLAction_set)
    __swig_setmethods__["mplsTTL"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsTTL_set
    __swig_getmethods__["mplsTTL"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsTTL_get
    if _newclass:mplsTTL = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsTTL_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsTTL_set)
    __swig_setmethods__["mplsCopyTTLOutwards"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsCopyTTLOutwards_set
    __swig_getmethods__["mplsCopyTTLOutwards"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsCopyTTLOutwards_get
    if _newclass:mplsCopyTTLOutwards = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsCopyTTLOutwards_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_mplsCopyTTLOutwards_set)
    __swig_setmethods__["lmepIdAction"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_lmepIdAction_set
    __swig_getmethods__["lmepIdAction"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_lmepIdAction_get
    if _newclass:lmepIdAction = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_lmepIdAction_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_lmepIdAction_set)
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_lmepId_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_lmepId_set)
    __swig_setmethods__["oamLmTxCountAction"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_oamLmTxCountAction_set
    __swig_getmethods__["oamLmTxCountAction"] = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_oamLmTxCountAction_get
    if _newclass:oamLmTxCountAction = _swig_property(_OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_oamLmTxCountAction_get, _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_oamLmTxCountAction_set)
    def __init__(self): 
        """__init__(ofdpaMPLSLabelGroupBucketData_s self) -> ofdpaMPLSLabelGroupBucketData_t"""
        this = _OFDPA_python.new_ofdpaMPLSLabelGroupBucketData_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMPLSLabelGroupBucketData_t
    __del__ = lambda self : None;
ofdpaMPLSLabelGroupBucketData_t_swigregister = _OFDPA_python.ofdpaMPLSLabelGroupBucketData_t_swigregister
ofdpaMPLSLabelGroupBucketData_t_swigregister(ofdpaMPLSLabelGroupBucketData_t)

class ofdpaMPLSFastFailOverGroupBucketData_t(_object):
    """Proxy of C ofdpaMPLSFastFailOverGroupBucketData_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMPLSFastFailOverGroupBucketData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMPLSFastFailOverGroupBucketData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["watchPort"] = _OFDPA_python.ofdpaMPLSFastFailOverGroupBucketData_t_watchPort_set
    __swig_getmethods__["watchPort"] = _OFDPA_python.ofdpaMPLSFastFailOverGroupBucketData_t_watchPort_get
    if _newclass:watchPort = _swig_property(_OFDPA_python.ofdpaMPLSFastFailOverGroupBucketData_t_watchPort_get, _OFDPA_python.ofdpaMPLSFastFailOverGroupBucketData_t_watchPort_set)
    def __init__(self): 
        """__init__(ofdpaMPLSFastFailOverGroupBucketData_s self) -> ofdpaMPLSFastFailOverGroupBucketData_t"""
        this = _OFDPA_python.new_ofdpaMPLSFastFailOverGroupBucketData_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMPLSFastFailOverGroupBucketData_t
    __del__ = lambda self : None;
ofdpaMPLSFastFailOverGroupBucketData_t_swigregister = _OFDPA_python.ofdpaMPLSFastFailOverGroupBucketData_t_swigregister
ofdpaMPLSFastFailOverGroupBucketData_t_swigregister(ofdpaMPLSFastFailOverGroupBucketData_t)

class ofdpaMPLSL2TagGroupBucketData_t(_object):
    """Proxy of C ofdpaMPLSL2TagGroupBucketData_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMPLSL2TagGroupBucketData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMPLSL2TagGroupBucketData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pushVlan"] = _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_pushVlan_set
    __swig_getmethods__["pushVlan"] = _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_pushVlan_get
    if _newclass:pushVlan = _swig_property(_OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_pushVlan_get, _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_pushVlan_set)
    __swig_setmethods__["newTpid"] = _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_newTpid_set
    __swig_getmethods__["newTpid"] = _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_newTpid_get
    if _newclass:newTpid = _swig_property(_OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_newTpid_get, _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_newTpid_set)
    __swig_setmethods__["popVlan"] = _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_popVlan_set
    __swig_getmethods__["popVlan"] = _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_popVlan_get
    if _newclass:popVlan = _swig_property(_OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_popVlan_get, _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_popVlan_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_vlanId_get, _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_vlanId_set)
    def __init__(self): 
        """__init__(ofdpaMPLSL2TagGroupBucketData_s self) -> ofdpaMPLSL2TagGroupBucketData_t"""
        this = _OFDPA_python.new_ofdpaMPLSL2TagGroupBucketData_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMPLSL2TagGroupBucketData_t
    __del__ = lambda self : None;
ofdpaMPLSL2TagGroupBucketData_t_swigregister = _OFDPA_python.ofdpaMPLSL2TagGroupBucketData_t_swigregister
ofdpaMPLSL2TagGroupBucketData_t_swigregister(ofdpaMPLSL2TagGroupBucketData_t)

class ofdpaL2UnfilteredInterfaceGroupBucketData_t(_object):
    """Proxy of C ofdpaL2UnfilteredInterfaceGroupBucketData_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaL2UnfilteredInterfaceGroupBucketData_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaL2UnfilteredInterfaceGroupBucketData_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["outputPort"] = _OFDPA_python.ofdpaL2UnfilteredInterfaceGroupBucketData_t_outputPort_set
    __swig_getmethods__["outputPort"] = _OFDPA_python.ofdpaL2UnfilteredInterfaceGroupBucketData_t_outputPort_get
    if _newclass:outputPort = _swig_property(_OFDPA_python.ofdpaL2UnfilteredInterfaceGroupBucketData_t_outputPort_get, _OFDPA_python.ofdpaL2UnfilteredInterfaceGroupBucketData_t_outputPort_set)
    __swig_setmethods__["allowVlanTranslation"] = _OFDPA_python.ofdpaL2UnfilteredInterfaceGroupBucketData_t_allowVlanTranslation_set
    __swig_getmethods__["allowVlanTranslation"] = _OFDPA_python.ofdpaL2UnfilteredInterfaceGroupBucketData_t_allowVlanTranslation_get
    if _newclass:allowVlanTranslation = _swig_property(_OFDPA_python.ofdpaL2UnfilteredInterfaceGroupBucketData_t_allowVlanTranslation_get, _OFDPA_python.ofdpaL2UnfilteredInterfaceGroupBucketData_t_allowVlanTranslation_set)
    def __init__(self): 
        """__init__(ofdpaL2UnfilteredInterfaceGroupBucketData_s self) -> ofdpaL2UnfilteredInterfaceGroupBucketData_t"""
        this = _OFDPA_python.new_ofdpaL2UnfilteredInterfaceGroupBucketData_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaL2UnfilteredInterfaceGroupBucketData_t
    __del__ = lambda self : None;
ofdpaL2UnfilteredInterfaceGroupBucketData_t_swigregister = _OFDPA_python.ofdpaL2UnfilteredInterfaceGroupBucketData_t_swigregister
ofdpaL2UnfilteredInterfaceGroupBucketData_t_swigregister(ofdpaL2UnfilteredInterfaceGroupBucketData_t)

class ofdpaGroupBucketEntry_t(_object):
    """Proxy of C ofdpaGroupBucketEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaGroupBucketEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaGroupBucketEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["groupId"] = _OFDPA_python.ofdpaGroupBucketEntry_t_groupId_set
    __swig_getmethods__["groupId"] = _OFDPA_python.ofdpaGroupBucketEntry_t_groupId_get
    if _newclass:groupId = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_t_groupId_get, _OFDPA_python.ofdpaGroupBucketEntry_t_groupId_set)
    __swig_setmethods__["bucketIndex"] = _OFDPA_python.ofdpaGroupBucketEntry_t_bucketIndex_set
    __swig_getmethods__["bucketIndex"] = _OFDPA_python.ofdpaGroupBucketEntry_t_bucketIndex_get
    if _newclass:bucketIndex = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_t_bucketIndex_get, _OFDPA_python.ofdpaGroupBucketEntry_t_bucketIndex_set)
    __swig_setmethods__["referenceGroupId"] = _OFDPA_python.ofdpaGroupBucketEntry_t_referenceGroupId_set
    __swig_getmethods__["referenceGroupId"] = _OFDPA_python.ofdpaGroupBucketEntry_t_referenceGroupId_get
    if _newclass:referenceGroupId = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_t_referenceGroupId_get, _OFDPA_python.ofdpaGroupBucketEntry_t_referenceGroupId_set)
    __swig_getmethods__["bucketData"] = _OFDPA_python.ofdpaGroupBucketEntry_t_bucketData_get
    if _newclass:bucketData = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_t_bucketData_get)
    def __init__(self): 
        """__init__(ofdpaGroupBucketEntry_s self) -> ofdpaGroupBucketEntry_t"""
        this = _OFDPA_python.new_ofdpaGroupBucketEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaGroupBucketEntry_t
    __del__ = lambda self : None;
ofdpaGroupBucketEntry_t_swigregister = _OFDPA_python.ofdpaGroupBucketEntry_t_swigregister
ofdpaGroupBucketEntry_t_swigregister(ofdpaGroupBucketEntry_t)

class ofdpaGroupBucketEntry_s_bucketData(_object):
    """Proxy of C ofdpaGroupBucketEntry_s_bucketData struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaGroupBucketEntry_s_bucketData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaGroupBucketEntry_s_bucketData, name)
    __repr__ = _swig_repr
    __swig_setmethods__["l2Interface"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Interface_set
    __swig_getmethods__["l2Interface"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Interface_get
    if _newclass:l2Interface = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Interface_get, _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Interface_set)
    __swig_setmethods__["l3Interface"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l3Interface_set
    __swig_getmethods__["l3Interface"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l3Interface_get
    if _newclass:l3Interface = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l3Interface_get, _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l3Interface_set)
    __swig_setmethods__["l3Unicast"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l3Unicast_set
    __swig_getmethods__["l3Unicast"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l3Unicast_get
    if _newclass:l3Unicast = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l3Unicast_get, _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l3Unicast_set)
    __swig_setmethods__["l2Rewrite"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Rewrite_set
    __swig_getmethods__["l2Rewrite"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Rewrite_get
    if _newclass:l2Rewrite = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Rewrite_get, _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Rewrite_set)
    __swig_setmethods__["l2Overlay"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Overlay_set
    __swig_getmethods__["l2Overlay"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Overlay_get
    if _newclass:l2Overlay = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Overlay_get, _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2Overlay_set)
    __swig_setmethods__["mplsInterface"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsInterface_set
    __swig_getmethods__["mplsInterface"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsInterface_get
    if _newclass:mplsInterface = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsInterface_get, _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsInterface_set)
    __swig_setmethods__["mplsLabel"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsLabel_set
    __swig_getmethods__["mplsLabel"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsLabel_get
    if _newclass:mplsLabel = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsLabel_get, _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsLabel_set)
    __swig_setmethods__["mplsFastFailOver"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsFastFailOver_set
    __swig_getmethods__["mplsFastFailOver"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsFastFailOver_get
    if _newclass:mplsFastFailOver = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsFastFailOver_get, _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsFastFailOver_set)
    __swig_setmethods__["mplsL2Tag"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsL2Tag_set
    __swig_getmethods__["mplsL2Tag"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsL2Tag_get
    if _newclass:mplsL2Tag = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsL2Tag_get, _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_mplsL2Tag_set)
    __swig_setmethods__["l2UnfilteredInterface"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2UnfilteredInterface_set
    __swig_getmethods__["l2UnfilteredInterface"] = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2UnfilteredInterface_get
    if _newclass:l2UnfilteredInterface = _swig_property(_OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2UnfilteredInterface_get, _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_l2UnfilteredInterface_set)
    def __init__(self): 
        """__init__(ofdpaGroupBucketEntry_s_bucketData self) -> ofdpaGroupBucketEntry_s_bucketData"""
        this = _OFDPA_python.new_ofdpaGroupBucketEntry_s_bucketData()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaGroupBucketEntry_s_bucketData
    __del__ = lambda self : None;
ofdpaGroupBucketEntry_s_bucketData_swigregister = _OFDPA_python.ofdpaGroupBucketEntry_s_bucketData_swigregister
ofdpaGroupBucketEntry_s_bucketData_swigregister(ofdpaGroupBucketEntry_s_bucketData)

class ofdpaGroupTableInfo_t(_object):
    """Proxy of C ofdpaGroupTableInfo_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaGroupTableInfo_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaGroupTableInfo_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["numGroupEntries"] = _OFDPA_python.ofdpaGroupTableInfo_t_numGroupEntries_set
    __swig_getmethods__["numGroupEntries"] = _OFDPA_python.ofdpaGroupTableInfo_t_numGroupEntries_get
    if _newclass:numGroupEntries = _swig_property(_OFDPA_python.ofdpaGroupTableInfo_t_numGroupEntries_get, _OFDPA_python.ofdpaGroupTableInfo_t_numGroupEntries_set)
    __swig_setmethods__["maxGroupEntries"] = _OFDPA_python.ofdpaGroupTableInfo_t_maxGroupEntries_set
    __swig_getmethods__["maxGroupEntries"] = _OFDPA_python.ofdpaGroupTableInfo_t_maxGroupEntries_get
    if _newclass:maxGroupEntries = _swig_property(_OFDPA_python.ofdpaGroupTableInfo_t_maxGroupEntries_get, _OFDPA_python.ofdpaGroupTableInfo_t_maxGroupEntries_set)
    __swig_setmethods__["maxBucketEntries"] = _OFDPA_python.ofdpaGroupTableInfo_t_maxBucketEntries_set
    __swig_getmethods__["maxBucketEntries"] = _OFDPA_python.ofdpaGroupTableInfo_t_maxBucketEntries_get
    if _newclass:maxBucketEntries = _swig_property(_OFDPA_python.ofdpaGroupTableInfo_t_maxBucketEntries_get, _OFDPA_python.ofdpaGroupTableInfo_t_maxBucketEntries_set)
    def __init__(self): 
        """__init__(ofdpaGroupTableInfo_s self) -> ofdpaGroupTableInfo_t"""
        this = _OFDPA_python.new_ofdpaGroupTableInfo_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaGroupTableInfo_t
    __del__ = lambda self : None;
ofdpaGroupTableInfo_t_swigregister = _OFDPA_python.ofdpaGroupTableInfo_t_swigregister
ofdpaGroupTableInfo_t_swigregister(ofdpaGroupTableInfo_t)

OFDPA_PORT_NAME_STRING_SIZE = _OFDPA_python.OFDPA_PORT_NAME_STRING_SIZE
OFDPA_PORT_CONFIG_DOWN = _OFDPA_python.OFDPA_PORT_CONFIG_DOWN
OFDPA_PORT_STATE_LINK_DOWN = _OFDPA_python.OFDPA_PORT_STATE_LINK_DOWN
OFDPA_PORT_STATE_BLOCKED = _OFDPA_python.OFDPA_PORT_STATE_BLOCKED
OFDPA_PORT_STATE_LIVE = _OFDPA_python.OFDPA_PORT_STATE_LIVE
OFDPA_PORT_FEAT_10MB_HD = _OFDPA_python.OFDPA_PORT_FEAT_10MB_HD
OFDPA_PORT_FEAT_10MB_FD = _OFDPA_python.OFDPA_PORT_FEAT_10MB_FD
OFDPA_PORT_FEAT_100MB_HD = _OFDPA_python.OFDPA_PORT_FEAT_100MB_HD
OFDPA_PORT_FEAT_100MB_FD = _OFDPA_python.OFDPA_PORT_FEAT_100MB_FD
OFDPA_PORT_FEAT_1GB_HD = _OFDPA_python.OFDPA_PORT_FEAT_1GB_HD
OFDPA_PORT_FEAT_1GB_FD = _OFDPA_python.OFDPA_PORT_FEAT_1GB_FD
OFDPA_PORT_FEAT_10GB_FD = _OFDPA_python.OFDPA_PORT_FEAT_10GB_FD
OFDPA_PORT_FEAT_40GB_FD = _OFDPA_python.OFDPA_PORT_FEAT_40GB_FD
OFDPA_PORT_FEAT_100GB_FD = _OFDPA_python.OFDPA_PORT_FEAT_100GB_FD
OFDPA_PORT_FEAT_1TB_FD = _OFDPA_python.OFDPA_PORT_FEAT_1TB_FD
OFDPA_PORT_FEAT_OTHER = _OFDPA_python.OFDPA_PORT_FEAT_OTHER
OFDPA_PORT_FEAT_COPPER = _OFDPA_python.OFDPA_PORT_FEAT_COPPER
OFDPA_PORT_FEAT_FIBER = _OFDPA_python.OFDPA_PORT_FEAT_FIBER
OFDPA_PORT_FEAT_AUTONEG = _OFDPA_python.OFDPA_PORT_FEAT_AUTONEG
OFDPA_PORT_FEAT_PAUSE = _OFDPA_python.OFDPA_PORT_FEAT_PAUSE
OFDPA_PORT_FEAT_PAUSE_ASYM = _OFDPA_python.OFDPA_PORT_FEAT_PAUSE_ASYM
class ofdpaPortFeature_t(_object):
    """Proxy of C ofdpaPortFeature_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaPortFeature_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaPortFeature_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["curr"] = _OFDPA_python.ofdpaPortFeature_t_curr_set
    __swig_getmethods__["curr"] = _OFDPA_python.ofdpaPortFeature_t_curr_get
    if _newclass:curr = _swig_property(_OFDPA_python.ofdpaPortFeature_t_curr_get, _OFDPA_python.ofdpaPortFeature_t_curr_set)
    __swig_setmethods__["advertised"] = _OFDPA_python.ofdpaPortFeature_t_advertised_set
    __swig_getmethods__["advertised"] = _OFDPA_python.ofdpaPortFeature_t_advertised_get
    if _newclass:advertised = _swig_property(_OFDPA_python.ofdpaPortFeature_t_advertised_get, _OFDPA_python.ofdpaPortFeature_t_advertised_set)
    __swig_setmethods__["supported"] = _OFDPA_python.ofdpaPortFeature_t_supported_set
    __swig_getmethods__["supported"] = _OFDPA_python.ofdpaPortFeature_t_supported_get
    if _newclass:supported = _swig_property(_OFDPA_python.ofdpaPortFeature_t_supported_get, _OFDPA_python.ofdpaPortFeature_t_supported_set)
    __swig_setmethods__["peer"] = _OFDPA_python.ofdpaPortFeature_t_peer_set
    __swig_getmethods__["peer"] = _OFDPA_python.ofdpaPortFeature_t_peer_get
    if _newclass:peer = _swig_property(_OFDPA_python.ofdpaPortFeature_t_peer_get, _OFDPA_python.ofdpaPortFeature_t_peer_set)
    def __init__(self): 
        """__init__(ofdpaPortFeature_s self) -> ofdpaPortFeature_t"""
        this = _OFDPA_python.new_ofdpaPortFeature_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaPortFeature_t
    __del__ = lambda self : None;
ofdpaPortFeature_t_swigregister = _OFDPA_python.ofdpaPortFeature_t_swigregister
ofdpaPortFeature_t_swigregister(ofdpaPortFeature_t)

class ofdpaPortStats_t(_object):
    """Proxy of C ofdpaPortStats_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaPortStats_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaPortStats_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["rx_packets"] = _OFDPA_python.ofdpaPortStats_t_rx_packets_set
    __swig_getmethods__["rx_packets"] = _OFDPA_python.ofdpaPortStats_t_rx_packets_get
    if _newclass:rx_packets = _swig_property(_OFDPA_python.ofdpaPortStats_t_rx_packets_get, _OFDPA_python.ofdpaPortStats_t_rx_packets_set)
    __swig_setmethods__["tx_packets"] = _OFDPA_python.ofdpaPortStats_t_tx_packets_set
    __swig_getmethods__["tx_packets"] = _OFDPA_python.ofdpaPortStats_t_tx_packets_get
    if _newclass:tx_packets = _swig_property(_OFDPA_python.ofdpaPortStats_t_tx_packets_get, _OFDPA_python.ofdpaPortStats_t_tx_packets_set)
    __swig_setmethods__["rx_bytes"] = _OFDPA_python.ofdpaPortStats_t_rx_bytes_set
    __swig_getmethods__["rx_bytes"] = _OFDPA_python.ofdpaPortStats_t_rx_bytes_get
    if _newclass:rx_bytes = _swig_property(_OFDPA_python.ofdpaPortStats_t_rx_bytes_get, _OFDPA_python.ofdpaPortStats_t_rx_bytes_set)
    __swig_setmethods__["tx_bytes"] = _OFDPA_python.ofdpaPortStats_t_tx_bytes_set
    __swig_getmethods__["tx_bytes"] = _OFDPA_python.ofdpaPortStats_t_tx_bytes_get
    if _newclass:tx_bytes = _swig_property(_OFDPA_python.ofdpaPortStats_t_tx_bytes_get, _OFDPA_python.ofdpaPortStats_t_tx_bytes_set)
    __swig_setmethods__["rx_errors"] = _OFDPA_python.ofdpaPortStats_t_rx_errors_set
    __swig_getmethods__["rx_errors"] = _OFDPA_python.ofdpaPortStats_t_rx_errors_get
    if _newclass:rx_errors = _swig_property(_OFDPA_python.ofdpaPortStats_t_rx_errors_get, _OFDPA_python.ofdpaPortStats_t_rx_errors_set)
    __swig_setmethods__["tx_errors"] = _OFDPA_python.ofdpaPortStats_t_tx_errors_set
    __swig_getmethods__["tx_errors"] = _OFDPA_python.ofdpaPortStats_t_tx_errors_get
    if _newclass:tx_errors = _swig_property(_OFDPA_python.ofdpaPortStats_t_tx_errors_get, _OFDPA_python.ofdpaPortStats_t_tx_errors_set)
    __swig_setmethods__["rx_drops"] = _OFDPA_python.ofdpaPortStats_t_rx_drops_set
    __swig_getmethods__["rx_drops"] = _OFDPA_python.ofdpaPortStats_t_rx_drops_get
    if _newclass:rx_drops = _swig_property(_OFDPA_python.ofdpaPortStats_t_rx_drops_get, _OFDPA_python.ofdpaPortStats_t_rx_drops_set)
    __swig_setmethods__["tx_drops"] = _OFDPA_python.ofdpaPortStats_t_tx_drops_set
    __swig_getmethods__["tx_drops"] = _OFDPA_python.ofdpaPortStats_t_tx_drops_get
    if _newclass:tx_drops = _swig_property(_OFDPA_python.ofdpaPortStats_t_tx_drops_get, _OFDPA_python.ofdpaPortStats_t_tx_drops_set)
    __swig_setmethods__["rx_frame_err"] = _OFDPA_python.ofdpaPortStats_t_rx_frame_err_set
    __swig_getmethods__["rx_frame_err"] = _OFDPA_python.ofdpaPortStats_t_rx_frame_err_get
    if _newclass:rx_frame_err = _swig_property(_OFDPA_python.ofdpaPortStats_t_rx_frame_err_get, _OFDPA_python.ofdpaPortStats_t_rx_frame_err_set)
    __swig_setmethods__["rx_over_err"] = _OFDPA_python.ofdpaPortStats_t_rx_over_err_set
    __swig_getmethods__["rx_over_err"] = _OFDPA_python.ofdpaPortStats_t_rx_over_err_get
    if _newclass:rx_over_err = _swig_property(_OFDPA_python.ofdpaPortStats_t_rx_over_err_get, _OFDPA_python.ofdpaPortStats_t_rx_over_err_set)
    __swig_setmethods__["rx_crc_err"] = _OFDPA_python.ofdpaPortStats_t_rx_crc_err_set
    __swig_getmethods__["rx_crc_err"] = _OFDPA_python.ofdpaPortStats_t_rx_crc_err_get
    if _newclass:rx_crc_err = _swig_property(_OFDPA_python.ofdpaPortStats_t_rx_crc_err_get, _OFDPA_python.ofdpaPortStats_t_rx_crc_err_set)
    __swig_setmethods__["collisions"] = _OFDPA_python.ofdpaPortStats_t_collisions_set
    __swig_getmethods__["collisions"] = _OFDPA_python.ofdpaPortStats_t_collisions_get
    if _newclass:collisions = _swig_property(_OFDPA_python.ofdpaPortStats_t_collisions_get, _OFDPA_python.ofdpaPortStats_t_collisions_set)
    __swig_setmethods__["duration_seconds"] = _OFDPA_python.ofdpaPortStats_t_duration_seconds_set
    __swig_getmethods__["duration_seconds"] = _OFDPA_python.ofdpaPortStats_t_duration_seconds_get
    if _newclass:duration_seconds = _swig_property(_OFDPA_python.ofdpaPortStats_t_duration_seconds_get, _OFDPA_python.ofdpaPortStats_t_duration_seconds_set)
    def __init__(self): 
        """__init__(ofdpaPortStats_s self) -> ofdpaPortStats_t"""
        this = _OFDPA_python.new_ofdpaPortStats_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaPortStats_t
    __del__ = lambda self : None;
ofdpaPortStats_t_swigregister = _OFDPA_python.ofdpaPortStats_t_swigregister
ofdpaPortStats_t_swigregister(ofdpaPortStats_t)

OFDPA_PKT_LOOKUP = _OFDPA_python.OFDPA_PKT_LOOKUP
OFDPA_PACKET_IN_REASON_NO_MATCH = _OFDPA_python.OFDPA_PACKET_IN_REASON_NO_MATCH
OFDPA_PACKET_IN_REASON_ACTION = _OFDPA_python.OFDPA_PACKET_IN_REASON_ACTION
OFDPA_PACKET_IN_REASON_INVALID_TTL = _OFDPA_python.OFDPA_PACKET_IN_REASON_INVALID_TTL
OFDPA_PACKET_IN_REASON_OAM = _OFDPA_python.OFDPA_PACKET_IN_REASON_OAM
class ofdpaPacket_t(_object):
    """Proxy of C ofdpaPacket_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaPacket_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaPacket_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["reason"] = _OFDPA_python.ofdpaPacket_t_reason_set
    __swig_getmethods__["reason"] = _OFDPA_python.ofdpaPacket_t_reason_get
    if _newclass:reason = _swig_property(_OFDPA_python.ofdpaPacket_t_reason_get, _OFDPA_python.ofdpaPacket_t_reason_set)
    __swig_setmethods__["tableId"] = _OFDPA_python.ofdpaPacket_t_tableId_set
    __swig_getmethods__["tableId"] = _OFDPA_python.ofdpaPacket_t_tableId_get
    if _newclass:tableId = _swig_property(_OFDPA_python.ofdpaPacket_t_tableId_get, _OFDPA_python.ofdpaPacket_t_tableId_set)
    __swig_setmethods__["inPortNum"] = _OFDPA_python.ofdpaPacket_t_inPortNum_set
    __swig_getmethods__["inPortNum"] = _OFDPA_python.ofdpaPacket_t_inPortNum_get
    if _newclass:inPortNum = _swig_property(_OFDPA_python.ofdpaPacket_t_inPortNum_get, _OFDPA_python.ofdpaPacket_t_inPortNum_set)
    __swig_setmethods__["pktData"] = _OFDPA_python.ofdpaPacket_t_pktData_set
    __swig_getmethods__["pktData"] = _OFDPA_python.ofdpaPacket_t_pktData_get
    if _newclass:pktData = _swig_property(_OFDPA_python.ofdpaPacket_t_pktData_get, _OFDPA_python.ofdpaPacket_t_pktData_set)
    def __init__(self): 
        """__init__(ofdpaPacket_s self) -> ofdpaPacket_t"""
        this = _OFDPA_python.new_ofdpaPacket_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaPacket_t
    __del__ = lambda self : None;
ofdpaPacket_t_swigregister = _OFDPA_python.ofdpaPacket_t_swigregister
ofdpaPacket_t_swigregister(ofdpaPacket_t)

OFDPA_EVENT_PORT_CREATE = _OFDPA_python.OFDPA_EVENT_PORT_CREATE
OFDPA_EVENT_PORT_DELETE = _OFDPA_python.OFDPA_EVENT_PORT_DELETE
OFDPA_EVENT_PORT_STATE = _OFDPA_python.OFDPA_EVENT_PORT_STATE
class ofdpaPortEvent_t(_object):
    """Proxy of C ofdpaPortEvent_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaPortEvent_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaPortEvent_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["eventMask"] = _OFDPA_python.ofdpaPortEvent_t_eventMask_set
    __swig_getmethods__["eventMask"] = _OFDPA_python.ofdpaPortEvent_t_eventMask_get
    if _newclass:eventMask = _swig_property(_OFDPA_python.ofdpaPortEvent_t_eventMask_get, _OFDPA_python.ofdpaPortEvent_t_eventMask_set)
    __swig_setmethods__["portNum"] = _OFDPA_python.ofdpaPortEvent_t_portNum_set
    __swig_getmethods__["portNum"] = _OFDPA_python.ofdpaPortEvent_t_portNum_get
    if _newclass:portNum = _swig_property(_OFDPA_python.ofdpaPortEvent_t_portNum_get, _OFDPA_python.ofdpaPortEvent_t_portNum_set)
    __swig_setmethods__["state"] = _OFDPA_python.ofdpaPortEvent_t_state_set
    __swig_getmethods__["state"] = _OFDPA_python.ofdpaPortEvent_t_state_get
    if _newclass:state = _swig_property(_OFDPA_python.ofdpaPortEvent_t_state_get, _OFDPA_python.ofdpaPortEvent_t_state_set)
    def __init__(self): 
        """__init__(ofdpaPortEvent_s self) -> ofdpaPortEvent_t"""
        this = _OFDPA_python.new_ofdpaPortEvent_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaPortEvent_t
    __del__ = lambda self : None;
ofdpaPortEvent_t_swigregister = _OFDPA_python.ofdpaPortEvent_t_swigregister
ofdpaPortEvent_t_swigregister(ofdpaPortEvent_t)

OFDPA_FLOW_EVENT_IDLE_TIMEOUT = _OFDPA_python.OFDPA_FLOW_EVENT_IDLE_TIMEOUT
OFDPA_FLOW_EVENT_HARD_TIMEOUT = _OFDPA_python.OFDPA_FLOW_EVENT_HARD_TIMEOUT
class ofdpaFlowEvent_t(_object):
    """Proxy of C ofdpaFlowEvent_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaFlowEvent_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaFlowEvent_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["eventMask"] = _OFDPA_python.ofdpaFlowEvent_t_eventMask_set
    __swig_getmethods__["eventMask"] = _OFDPA_python.ofdpaFlowEvent_t_eventMask_get
    if _newclass:eventMask = _swig_property(_OFDPA_python.ofdpaFlowEvent_t_eventMask_get, _OFDPA_python.ofdpaFlowEvent_t_eventMask_set)
    __swig_setmethods__["flowMatch"] = _OFDPA_python.ofdpaFlowEvent_t_flowMatch_set
    __swig_getmethods__["flowMatch"] = _OFDPA_python.ofdpaFlowEvent_t_flowMatch_get
    if _newclass:flowMatch = _swig_property(_OFDPA_python.ofdpaFlowEvent_t_flowMatch_get, _OFDPA_python.ofdpaFlowEvent_t_flowMatch_set)
    def __init__(self): 
        """__init__(ofdpaFlowEvent_s self) -> ofdpaFlowEvent_t"""
        this = _OFDPA_python.new_ofdpaFlowEvent_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaFlowEvent_t
    __del__ = lambda self : None;
ofdpaFlowEvent_t_swigregister = _OFDPA_python.ofdpaFlowEvent_t_swigregister
ofdpaFlowEvent_t_swigregister(ofdpaFlowEvent_t)

OFDPA_TUNNEL_PORT_TYPE_ENDPOINT = _OFDPA_python.OFDPA_TUNNEL_PORT_TYPE_ENDPOINT
OFDPA_TUNNEL_PORT_TYPE_ACCESS = _OFDPA_python.OFDPA_TUNNEL_PORT_TYPE_ACCESS
OFDPA_TUNNEL_PROTO_VXLAN = _OFDPA_python.OFDPA_TUNNEL_PROTO_VXLAN
class ofdpaVxlanProtoInfo_t(_object):
    """Proxy of C ofdpaVxlanProtoInfo_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaVxlanProtoInfo_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaVxlanProtoInfo_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["terminatorUdpDstPort"] = _OFDPA_python.ofdpaVxlanProtoInfo_t_terminatorUdpDstPort_set
    __swig_getmethods__["terminatorUdpDstPort"] = _OFDPA_python.ofdpaVxlanProtoInfo_t_terminatorUdpDstPort_get
    if _newclass:terminatorUdpDstPort = _swig_property(_OFDPA_python.ofdpaVxlanProtoInfo_t_terminatorUdpDstPort_get, _OFDPA_python.ofdpaVxlanProtoInfo_t_terminatorUdpDstPort_set)
    __swig_setmethods__["initiatorUdpDstPort"] = _OFDPA_python.ofdpaVxlanProtoInfo_t_initiatorUdpDstPort_set
    __swig_getmethods__["initiatorUdpDstPort"] = _OFDPA_python.ofdpaVxlanProtoInfo_t_initiatorUdpDstPort_get
    if _newclass:initiatorUdpDstPort = _swig_property(_OFDPA_python.ofdpaVxlanProtoInfo_t_initiatorUdpDstPort_get, _OFDPA_python.ofdpaVxlanProtoInfo_t_initiatorUdpDstPort_set)
    __swig_setmethods__["udpSrcPortIfNoEntropy"] = _OFDPA_python.ofdpaVxlanProtoInfo_t_udpSrcPortIfNoEntropy_set
    __swig_getmethods__["udpSrcPortIfNoEntropy"] = _OFDPA_python.ofdpaVxlanProtoInfo_t_udpSrcPortIfNoEntropy_get
    if _newclass:udpSrcPortIfNoEntropy = _swig_property(_OFDPA_python.ofdpaVxlanProtoInfo_t_udpSrcPortIfNoEntropy_get, _OFDPA_python.ofdpaVxlanProtoInfo_t_udpSrcPortIfNoEntropy_set)
    __swig_setmethods__["useEntropy"] = _OFDPA_python.ofdpaVxlanProtoInfo_t_useEntropy_set
    __swig_getmethods__["useEntropy"] = _OFDPA_python.ofdpaVxlanProtoInfo_t_useEntropy_get
    if _newclass:useEntropy = _swig_property(_OFDPA_python.ofdpaVxlanProtoInfo_t_useEntropy_get, _OFDPA_python.ofdpaVxlanProtoInfo_t_useEntropy_set)
    def __init__(self): 
        """__init__(ofdpaVxlanProtoInfo_t self) -> ofdpaVxlanProtoInfo_t"""
        this = _OFDPA_python.new_ofdpaVxlanProtoInfo_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaVxlanProtoInfo_t
    __del__ = lambda self : None;
ofdpaVxlanProtoInfo_t_swigregister = _OFDPA_python.ofdpaVxlanProtoInfo_t_swigregister
ofdpaVxlanProtoInfo_t_swigregister(ofdpaVxlanProtoInfo_t)

class ofdpaAccessPortConfig_t(_object):
    """Proxy of C ofdpaAccessPortConfig_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaAccessPortConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaAccessPortConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["physicalPortNum"] = _OFDPA_python.ofdpaAccessPortConfig_t_physicalPortNum_set
    __swig_getmethods__["physicalPortNum"] = _OFDPA_python.ofdpaAccessPortConfig_t_physicalPortNum_get
    if _newclass:physicalPortNum = _swig_property(_OFDPA_python.ofdpaAccessPortConfig_t_physicalPortNum_get, _OFDPA_python.ofdpaAccessPortConfig_t_physicalPortNum_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaAccessPortConfig_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaAccessPortConfig_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaAccessPortConfig_t_vlanId_get, _OFDPA_python.ofdpaAccessPortConfig_t_vlanId_set)
    __swig_setmethods__["etag"] = _OFDPA_python.ofdpaAccessPortConfig_t_etag_set
    __swig_getmethods__["etag"] = _OFDPA_python.ofdpaAccessPortConfig_t_etag_get
    if _newclass:etag = _swig_property(_OFDPA_python.ofdpaAccessPortConfig_t_etag_get, _OFDPA_python.ofdpaAccessPortConfig_t_etag_set)
    __swig_setmethods__["untagged"] = _OFDPA_python.ofdpaAccessPortConfig_t_untagged_set
    __swig_getmethods__["untagged"] = _OFDPA_python.ofdpaAccessPortConfig_t_untagged_get
    if _newclass:untagged = _swig_property(_OFDPA_python.ofdpaAccessPortConfig_t_untagged_get, _OFDPA_python.ofdpaAccessPortConfig_t_untagged_set)
    __swig_setmethods__["useEtag"] = _OFDPA_python.ofdpaAccessPortConfig_t_useEtag_set
    __swig_getmethods__["useEtag"] = _OFDPA_python.ofdpaAccessPortConfig_t_useEtag_get
    if _newclass:useEtag = _swig_property(_OFDPA_python.ofdpaAccessPortConfig_t_useEtag_get, _OFDPA_python.ofdpaAccessPortConfig_t_useEtag_set)
    def __init__(self): 
        """__init__(ofdpaAccessPortConfig_t self) -> ofdpaAccessPortConfig_t"""
        this = _OFDPA_python.new_ofdpaAccessPortConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaAccessPortConfig_t
    __del__ = lambda self : None;
ofdpaAccessPortConfig_t_swigregister = _OFDPA_python.ofdpaAccessPortConfig_t_swigregister
ofdpaAccessPortConfig_t_swigregister(ofdpaAccessPortConfig_t)

class ofdpaEndpointConfig_t(_object):
    """Proxy of C ofdpaEndpointConfig_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEndpointConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEndpointConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["remoteEndpoint"] = _OFDPA_python.ofdpaEndpointConfig_t_remoteEndpoint_set
    __swig_getmethods__["remoteEndpoint"] = _OFDPA_python.ofdpaEndpointConfig_t_remoteEndpoint_get
    if _newclass:remoteEndpoint = _swig_property(_OFDPA_python.ofdpaEndpointConfig_t_remoteEndpoint_get, _OFDPA_python.ofdpaEndpointConfig_t_remoteEndpoint_set)
    __swig_setmethods__["localEndpoint"] = _OFDPA_python.ofdpaEndpointConfig_t_localEndpoint_set
    __swig_getmethods__["localEndpoint"] = _OFDPA_python.ofdpaEndpointConfig_t_localEndpoint_get
    if _newclass:localEndpoint = _swig_property(_OFDPA_python.ofdpaEndpointConfig_t_localEndpoint_get, _OFDPA_python.ofdpaEndpointConfig_t_localEndpoint_set)
    __swig_setmethods__["ttl"] = _OFDPA_python.ofdpaEndpointConfig_t_ttl_set
    __swig_getmethods__["ttl"] = _OFDPA_python.ofdpaEndpointConfig_t_ttl_get
    if _newclass:ttl = _swig_property(_OFDPA_python.ofdpaEndpointConfig_t_ttl_get, _OFDPA_python.ofdpaEndpointConfig_t_ttl_set)
    __swig_setmethods__["ecmp"] = _OFDPA_python.ofdpaEndpointConfig_t_ecmp_set
    __swig_getmethods__["ecmp"] = _OFDPA_python.ofdpaEndpointConfig_t_ecmp_get
    if _newclass:ecmp = _swig_property(_OFDPA_python.ofdpaEndpointConfig_t_ecmp_get, _OFDPA_python.ofdpaEndpointConfig_t_ecmp_set)
    __swig_setmethods__["nextHopId"] = _OFDPA_python.ofdpaEndpointConfig_t_nextHopId_set
    __swig_getmethods__["nextHopId"] = _OFDPA_python.ofdpaEndpointConfig_t_nextHopId_get
    if _newclass:nextHopId = _swig_property(_OFDPA_python.ofdpaEndpointConfig_t_nextHopId_get, _OFDPA_python.ofdpaEndpointConfig_t_nextHopId_set)
    __swig_getmethods__["protocolInfo"] = _OFDPA_python.ofdpaEndpointConfig_t_protocolInfo_get
    if _newclass:protocolInfo = _swig_property(_OFDPA_python.ofdpaEndpointConfig_t_protocolInfo_get)
    def __init__(self): 
        """__init__(ofdpaEndpointConfig_t self) -> ofdpaEndpointConfig_t"""
        this = _OFDPA_python.new_ofdpaEndpointConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEndpointConfig_t
    __del__ = lambda self : None;
ofdpaEndpointConfig_t_swigregister = _OFDPA_python.ofdpaEndpointConfig_t_swigregister
ofdpaEndpointConfig_t_swigregister(ofdpaEndpointConfig_t)

class ofdpaEndpointConfig_t_protocolInfo(_object):
    """Proxy of C ofdpaEndpointConfig_t_protocolInfo struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaEndpointConfig_t_protocolInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaEndpointConfig_t_protocolInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["vxlan"] = _OFDPA_python.ofdpaEndpointConfig_t_protocolInfo_vxlan_set
    __swig_getmethods__["vxlan"] = _OFDPA_python.ofdpaEndpointConfig_t_protocolInfo_vxlan_get
    if _newclass:vxlan = _swig_property(_OFDPA_python.ofdpaEndpointConfig_t_protocolInfo_vxlan_get, _OFDPA_python.ofdpaEndpointConfig_t_protocolInfo_vxlan_set)
    def __init__(self): 
        """__init__(ofdpaEndpointConfig_t_protocolInfo self) -> ofdpaEndpointConfig_t_protocolInfo"""
        this = _OFDPA_python.new_ofdpaEndpointConfig_t_protocolInfo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaEndpointConfig_t_protocolInfo
    __del__ = lambda self : None;
ofdpaEndpointConfig_t_protocolInfo_swigregister = _OFDPA_python.ofdpaEndpointConfig_t_protocolInfo_swigregister
ofdpaEndpointConfig_t_protocolInfo_swigregister(ofdpaEndpointConfig_t_protocolInfo)

class ofdpaTunnelPortConfig_t(_object):
    """Proxy of C ofdpaTunnelPortConfig_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTunnelPortConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTunnelPortConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["type"] = _OFDPA_python.ofdpaTunnelPortConfig_t_type_set
    __swig_getmethods__["type"] = _OFDPA_python.ofdpaTunnelPortConfig_t_type_get
    if _newclass:type = _swig_property(_OFDPA_python.ofdpaTunnelPortConfig_t_type_get, _OFDPA_python.ofdpaTunnelPortConfig_t_type_set)
    __swig_setmethods__["tunnelProtocol"] = _OFDPA_python.ofdpaTunnelPortConfig_t_tunnelProtocol_set
    __swig_getmethods__["tunnelProtocol"] = _OFDPA_python.ofdpaTunnelPortConfig_t_tunnelProtocol_get
    if _newclass:tunnelProtocol = _swig_property(_OFDPA_python.ofdpaTunnelPortConfig_t_tunnelProtocol_get, _OFDPA_python.ofdpaTunnelPortConfig_t_tunnelProtocol_set)
    __swig_getmethods__["configData"] = _OFDPA_python.ofdpaTunnelPortConfig_t_configData_get
    if _newclass:configData = _swig_property(_OFDPA_python.ofdpaTunnelPortConfig_t_configData_get)
    def __init__(self): 
        """__init__(ofdpaTunnelPortConfig_t self) -> ofdpaTunnelPortConfig_t"""
        this = _OFDPA_python.new_ofdpaTunnelPortConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTunnelPortConfig_t
    __del__ = lambda self : None;
ofdpaTunnelPortConfig_t_swigregister = _OFDPA_python.ofdpaTunnelPortConfig_t_swigregister
ofdpaTunnelPortConfig_t_swigregister(ofdpaTunnelPortConfig_t)

class ofdpaTunnelPortConfig_t_configData(_object):
    """Proxy of C ofdpaTunnelPortConfig_t_configData struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTunnelPortConfig_t_configData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTunnelPortConfig_t_configData, name)
    __repr__ = _swig_repr
    __swig_setmethods__["access"] = _OFDPA_python.ofdpaTunnelPortConfig_t_configData_access_set
    __swig_getmethods__["access"] = _OFDPA_python.ofdpaTunnelPortConfig_t_configData_access_get
    if _newclass:access = _swig_property(_OFDPA_python.ofdpaTunnelPortConfig_t_configData_access_get, _OFDPA_python.ofdpaTunnelPortConfig_t_configData_access_set)
    __swig_setmethods__["endpoint"] = _OFDPA_python.ofdpaTunnelPortConfig_t_configData_endpoint_set
    __swig_getmethods__["endpoint"] = _OFDPA_python.ofdpaTunnelPortConfig_t_configData_endpoint_get
    if _newclass:endpoint = _swig_property(_OFDPA_python.ofdpaTunnelPortConfig_t_configData_endpoint_get, _OFDPA_python.ofdpaTunnelPortConfig_t_configData_endpoint_set)
    def __init__(self): 
        """__init__(ofdpaTunnelPortConfig_t_configData self) -> ofdpaTunnelPortConfig_t_configData"""
        this = _OFDPA_python.new_ofdpaTunnelPortConfig_t_configData()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTunnelPortConfig_t_configData
    __del__ = lambda self : None;
ofdpaTunnelPortConfig_t_configData_swigregister = _OFDPA_python.ofdpaTunnelPortConfig_t_configData_swigregister
ofdpaTunnelPortConfig_t_configData_swigregister(ofdpaTunnelPortConfig_t_configData)

class ofdpaTunnelPortStatus_t(_object):
    """Proxy of C ofdpaTunnelPortStatus_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTunnelPortStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTunnelPortStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaTunnelPortStatus_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaTunnelPortStatus_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaTunnelPortStatus_t_refCount_get, _OFDPA_python.ofdpaTunnelPortStatus_t_refCount_set)
    __swig_setmethods__["tenantCount"] = _OFDPA_python.ofdpaTunnelPortStatus_t_tenantCount_set
    __swig_getmethods__["tenantCount"] = _OFDPA_python.ofdpaTunnelPortStatus_t_tenantCount_get
    if _newclass:tenantCount = _swig_property(_OFDPA_python.ofdpaTunnelPortStatus_t_tenantCount_get, _OFDPA_python.ofdpaTunnelPortStatus_t_tenantCount_set)
    def __init__(self): 
        """__init__(ofdpaTunnelPortStatus_t self) -> ofdpaTunnelPortStatus_t"""
        this = _OFDPA_python.new_ofdpaTunnelPortStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTunnelPortStatus_t
    __del__ = lambda self : None;
ofdpaTunnelPortStatus_t_swigregister = _OFDPA_python.ofdpaTunnelPortStatus_t_swigregister
ofdpaTunnelPortStatus_t_swigregister(ofdpaTunnelPortStatus_t)

class ofdpaTunnelPortTenantStatus_t(_object):
    """Proxy of C ofdpaTunnelPortTenantStatus_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTunnelPortTenantStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTunnelPortTenantStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaTunnelPortTenantStatus_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaTunnelPortTenantStatus_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaTunnelPortTenantStatus_t_refCount_get, _OFDPA_python.ofdpaTunnelPortTenantStatus_t_refCount_set)
    def __init__(self): 
        """__init__(ofdpaTunnelPortTenantStatus_t self) -> ofdpaTunnelPortTenantStatus_t"""
        this = _OFDPA_python.new_ofdpaTunnelPortTenantStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTunnelPortTenantStatus_t
    __del__ = lambda self : None;
ofdpaTunnelPortTenantStatus_t_swigregister = _OFDPA_python.ofdpaTunnelPortTenantStatus_t_swigregister
ofdpaTunnelPortTenantStatus_t_swigregister(ofdpaTunnelPortTenantStatus_t)

class ofdpaTunnelTenantConfig_t(_object):
    """Proxy of C ofdpaTunnelTenantConfig_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTunnelTenantConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTunnelTenantConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["protocol"] = _OFDPA_python.ofdpaTunnelTenantConfig_t_protocol_set
    __swig_getmethods__["protocol"] = _OFDPA_python.ofdpaTunnelTenantConfig_t_protocol_get
    if _newclass:protocol = _swig_property(_OFDPA_python.ofdpaTunnelTenantConfig_t_protocol_get, _OFDPA_python.ofdpaTunnelTenantConfig_t_protocol_set)
    __swig_setmethods__["virtualNetworkId"] = _OFDPA_python.ofdpaTunnelTenantConfig_t_virtualNetworkId_set
    __swig_getmethods__["virtualNetworkId"] = _OFDPA_python.ofdpaTunnelTenantConfig_t_virtualNetworkId_get
    if _newclass:virtualNetworkId = _swig_property(_OFDPA_python.ofdpaTunnelTenantConfig_t_virtualNetworkId_get, _OFDPA_python.ofdpaTunnelTenantConfig_t_virtualNetworkId_set)
    __swig_setmethods__["mcastIp"] = _OFDPA_python.ofdpaTunnelTenantConfig_t_mcastIp_set
    __swig_getmethods__["mcastIp"] = _OFDPA_python.ofdpaTunnelTenantConfig_t_mcastIp_get
    if _newclass:mcastIp = _swig_property(_OFDPA_python.ofdpaTunnelTenantConfig_t_mcastIp_get, _OFDPA_python.ofdpaTunnelTenantConfig_t_mcastIp_set)
    __swig_setmethods__["mcastNextHopId"] = _OFDPA_python.ofdpaTunnelTenantConfig_t_mcastNextHopId_set
    __swig_getmethods__["mcastNextHopId"] = _OFDPA_python.ofdpaTunnelTenantConfig_t_mcastNextHopId_get
    if _newclass:mcastNextHopId = _swig_property(_OFDPA_python.ofdpaTunnelTenantConfig_t_mcastNextHopId_get, _OFDPA_python.ofdpaTunnelTenantConfig_t_mcastNextHopId_set)
    def __init__(self): 
        """__init__(ofdpaTunnelTenantConfig_t self) -> ofdpaTunnelTenantConfig_t"""
        this = _OFDPA_python.new_ofdpaTunnelTenantConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTunnelTenantConfig_t
    __del__ = lambda self : None;
ofdpaTunnelTenantConfig_t_swigregister = _OFDPA_python.ofdpaTunnelTenantConfig_t_swigregister
ofdpaTunnelTenantConfig_t_swigregister(ofdpaTunnelTenantConfig_t)

class ofdpaTunnelTenantStatus_t(_object):
    """Proxy of C ofdpaTunnelTenantStatus_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTunnelTenantStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTunnelTenantStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaTunnelTenantStatus_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaTunnelTenantStatus_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaTunnelTenantStatus_t_refCount_get, _OFDPA_python.ofdpaTunnelTenantStatus_t_refCount_set)
    def __init__(self): 
        """__init__(ofdpaTunnelTenantStatus_t self) -> ofdpaTunnelTenantStatus_t"""
        this = _OFDPA_python.new_ofdpaTunnelTenantStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTunnelTenantStatus_t
    __del__ = lambda self : None;
ofdpaTunnelTenantStatus_t_swigregister = _OFDPA_python.ofdpaTunnelTenantStatus_t_swigregister
ofdpaTunnelTenantStatus_t_swigregister(ofdpaTunnelTenantStatus_t)

class ofdpaTunnelNextHopConfig_t(_object):
    """Proxy of C ofdpaTunnelNextHopConfig_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTunnelNextHopConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTunnelNextHopConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["protocol"] = _OFDPA_python.ofdpaTunnelNextHopConfig_t_protocol_set
    __swig_getmethods__["protocol"] = _OFDPA_python.ofdpaTunnelNextHopConfig_t_protocol_get
    if _newclass:protocol = _swig_property(_OFDPA_python.ofdpaTunnelNextHopConfig_t_protocol_get, _OFDPA_python.ofdpaTunnelNextHopConfig_t_protocol_set)
    __swig_setmethods__["srcAddr"] = _OFDPA_python.ofdpaTunnelNextHopConfig_t_srcAddr_set
    __swig_getmethods__["srcAddr"] = _OFDPA_python.ofdpaTunnelNextHopConfig_t_srcAddr_get
    if _newclass:srcAddr = _swig_property(_OFDPA_python.ofdpaTunnelNextHopConfig_t_srcAddr_get, _OFDPA_python.ofdpaTunnelNextHopConfig_t_srcAddr_set)
    __swig_setmethods__["dstAddr"] = _OFDPA_python.ofdpaTunnelNextHopConfig_t_dstAddr_set
    __swig_getmethods__["dstAddr"] = _OFDPA_python.ofdpaTunnelNextHopConfig_t_dstAddr_get
    if _newclass:dstAddr = _swig_property(_OFDPA_python.ofdpaTunnelNextHopConfig_t_dstAddr_get, _OFDPA_python.ofdpaTunnelNextHopConfig_t_dstAddr_set)
    __swig_setmethods__["physicalPortNum"] = _OFDPA_python.ofdpaTunnelNextHopConfig_t_physicalPortNum_set
    __swig_getmethods__["physicalPortNum"] = _OFDPA_python.ofdpaTunnelNextHopConfig_t_physicalPortNum_get
    if _newclass:physicalPortNum = _swig_property(_OFDPA_python.ofdpaTunnelNextHopConfig_t_physicalPortNum_get, _OFDPA_python.ofdpaTunnelNextHopConfig_t_physicalPortNum_set)
    __swig_setmethods__["vlanId"] = _OFDPA_python.ofdpaTunnelNextHopConfig_t_vlanId_set
    __swig_getmethods__["vlanId"] = _OFDPA_python.ofdpaTunnelNextHopConfig_t_vlanId_get
    if _newclass:vlanId = _swig_property(_OFDPA_python.ofdpaTunnelNextHopConfig_t_vlanId_get, _OFDPA_python.ofdpaTunnelNextHopConfig_t_vlanId_set)
    def __init__(self): 
        """__init__(ofdpaTunnelNextHopConfig_t self) -> ofdpaTunnelNextHopConfig_t"""
        this = _OFDPA_python.new_ofdpaTunnelNextHopConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTunnelNextHopConfig_t
    __del__ = lambda self : None;
ofdpaTunnelNextHopConfig_t_swigregister = _OFDPA_python.ofdpaTunnelNextHopConfig_t_swigregister
ofdpaTunnelNextHopConfig_t_swigregister(ofdpaTunnelNextHopConfig_t)

class ofdpaTunnelNextHopStatus_t(_object):
    """Proxy of C ofdpaTunnelNextHopStatus_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTunnelNextHopStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTunnelNextHopStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaTunnelNextHopStatus_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaTunnelNextHopStatus_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaTunnelNextHopStatus_t_refCount_get, _OFDPA_python.ofdpaTunnelNextHopStatus_t_refCount_set)
    def __init__(self): 
        """__init__(ofdpaTunnelNextHopStatus_t self) -> ofdpaTunnelNextHopStatus_t"""
        this = _OFDPA_python.new_ofdpaTunnelNextHopStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTunnelNextHopStatus_t
    __del__ = lambda self : None;
ofdpaTunnelNextHopStatus_t_swigregister = _OFDPA_python.ofdpaTunnelNextHopStatus_t_swigregister
ofdpaTunnelNextHopStatus_t_swigregister(ofdpaTunnelNextHopStatus_t)

class ofdpaTunnelEcmpNextHopGroupConfig_t(_object):
    """Proxy of C ofdpaTunnelEcmpNextHopGroupConfig_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTunnelEcmpNextHopGroupConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTunnelEcmpNextHopGroupConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["protocol"] = _OFDPA_python.ofdpaTunnelEcmpNextHopGroupConfig_t_protocol_set
    __swig_getmethods__["protocol"] = _OFDPA_python.ofdpaTunnelEcmpNextHopGroupConfig_t_protocol_get
    if _newclass:protocol = _swig_property(_OFDPA_python.ofdpaTunnelEcmpNextHopGroupConfig_t_protocol_get, _OFDPA_python.ofdpaTunnelEcmpNextHopGroupConfig_t_protocol_set)
    def __init__(self): 
        """__init__(ofdpaTunnelEcmpNextHopGroupConfig_t self) -> ofdpaTunnelEcmpNextHopGroupConfig_t"""
        this = _OFDPA_python.new_ofdpaTunnelEcmpNextHopGroupConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTunnelEcmpNextHopGroupConfig_t
    __del__ = lambda self : None;
ofdpaTunnelEcmpNextHopGroupConfig_t_swigregister = _OFDPA_python.ofdpaTunnelEcmpNextHopGroupConfig_t_swigregister
ofdpaTunnelEcmpNextHopGroupConfig_t_swigregister(ofdpaTunnelEcmpNextHopGroupConfig_t)

class ofdpaTunnelEcmpNextHopGroupStatus_t(_object):
    """Proxy of C ofdpaTunnelEcmpNextHopGroupStatus_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaTunnelEcmpNextHopGroupStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaTunnelEcmpNextHopGroupStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaTunnelEcmpNextHopGroupStatus_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaTunnelEcmpNextHopGroupStatus_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaTunnelEcmpNextHopGroupStatus_t_refCount_get, _OFDPA_python.ofdpaTunnelEcmpNextHopGroupStatus_t_refCount_set)
    __swig_setmethods__["memberCount"] = _OFDPA_python.ofdpaTunnelEcmpNextHopGroupStatus_t_memberCount_set
    __swig_getmethods__["memberCount"] = _OFDPA_python.ofdpaTunnelEcmpNextHopGroupStatus_t_memberCount_get
    if _newclass:memberCount = _swig_property(_OFDPA_python.ofdpaTunnelEcmpNextHopGroupStatus_t_memberCount_get, _OFDPA_python.ofdpaTunnelEcmpNextHopGroupStatus_t_memberCount_set)
    def __init__(self): 
        """__init__(ofdpaTunnelEcmpNextHopGroupStatus_t self) -> ofdpaTunnelEcmpNextHopGroupStatus_t"""
        this = _OFDPA_python.new_ofdpaTunnelEcmpNextHopGroupStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaTunnelEcmpNextHopGroupStatus_t
    __del__ = lambda self : None;
ofdpaTunnelEcmpNextHopGroupStatus_t_swigregister = _OFDPA_python.ofdpaTunnelEcmpNextHopGroupStatus_t_swigregister
ofdpaTunnelEcmpNextHopGroupStatus_t_swigregister(ofdpaTunnelEcmpNextHopGroupStatus_t)

OFDPA_TABLE_NAME_LEN = _OFDPA_python.OFDPA_TABLE_NAME_LEN
class ofdpaFlowTableInfo_t(_object):
    """Proxy of C ofdpaFlowTableInfo_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaFlowTableInfo_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaFlowTableInfo_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["numEntries"] = _OFDPA_python.ofdpaFlowTableInfo_t_numEntries_set
    __swig_getmethods__["numEntries"] = _OFDPA_python.ofdpaFlowTableInfo_t_numEntries_get
    if _newclass:numEntries = _swig_property(_OFDPA_python.ofdpaFlowTableInfo_t_numEntries_get, _OFDPA_python.ofdpaFlowTableInfo_t_numEntries_set)
    __swig_setmethods__["maxEntries"] = _OFDPA_python.ofdpaFlowTableInfo_t_maxEntries_set
    __swig_getmethods__["maxEntries"] = _OFDPA_python.ofdpaFlowTableInfo_t_maxEntries_get
    if _newclass:maxEntries = _swig_property(_OFDPA_python.ofdpaFlowTableInfo_t_maxEntries_get, _OFDPA_python.ofdpaFlowTableInfo_t_maxEntries_set)
    def __init__(self): 
        """__init__(ofdpaFlowTableInfo_s self) -> ofdpaFlowTableInfo_t"""
        this = _OFDPA_python.new_ofdpaFlowTableInfo_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaFlowTableInfo_t
    __del__ = lambda self : None;
ofdpaFlowTableInfo_t_swigregister = _OFDPA_python.ofdpaFlowTableInfo_t_swigregister
ofdpaFlowTableInfo_t_swigregister(ofdpaFlowTableInfo_t)

class ofdpaPortQueueStats_t(_object):
    """Proxy of C ofdpaPortQueueStats_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaPortQueueStats_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaPortQueueStats_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["txBytes"] = _OFDPA_python.ofdpaPortQueueStats_t_txBytes_set
    __swig_getmethods__["txBytes"] = _OFDPA_python.ofdpaPortQueueStats_t_txBytes_get
    if _newclass:txBytes = _swig_property(_OFDPA_python.ofdpaPortQueueStats_t_txBytes_get, _OFDPA_python.ofdpaPortQueueStats_t_txBytes_set)
    __swig_setmethods__["txPkts"] = _OFDPA_python.ofdpaPortQueueStats_t_txPkts_set
    __swig_getmethods__["txPkts"] = _OFDPA_python.ofdpaPortQueueStats_t_txPkts_get
    if _newclass:txPkts = _swig_property(_OFDPA_python.ofdpaPortQueueStats_t_txPkts_get, _OFDPA_python.ofdpaPortQueueStats_t_txPkts_set)
    __swig_setmethods__["duration_seconds"] = _OFDPA_python.ofdpaPortQueueStats_t_duration_seconds_set
    __swig_getmethods__["duration_seconds"] = _OFDPA_python.ofdpaPortQueueStats_t_duration_seconds_get
    if _newclass:duration_seconds = _swig_property(_OFDPA_python.ofdpaPortQueueStats_t_duration_seconds_get, _OFDPA_python.ofdpaPortQueueStats_t_duration_seconds_set)
    def __init__(self): 
        """__init__(ofdpaPortQueueStats_s self) -> ofdpaPortQueueStats_t"""
        this = _OFDPA_python.new_ofdpaPortQueueStats_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaPortQueueStats_t
    __del__ = lambda self : None;
ofdpaPortQueueStats_t_swigregister = _OFDPA_python.ofdpaPortQueueStats_t_swigregister
ofdpaPortQueueStats_t_swigregister(ofdpaPortQueueStats_t)

class ofdpaSrcMacLearnModeCfg_t(_object):
    """Proxy of C ofdpaSrcMacLearnModeCfg_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaSrcMacLearnModeCfg_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaSrcMacLearnModeCfg_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["destPortNum"] = _OFDPA_python.ofdpaSrcMacLearnModeCfg_t_destPortNum_set
    __swig_getmethods__["destPortNum"] = _OFDPA_python.ofdpaSrcMacLearnModeCfg_t_destPortNum_get
    if _newclass:destPortNum = _swig_property(_OFDPA_python.ofdpaSrcMacLearnModeCfg_t_destPortNum_get, _OFDPA_python.ofdpaSrcMacLearnModeCfg_t_destPortNum_set)
    def __init__(self): 
        """__init__(ofdpaSrcMacLearnModeCfg_s self) -> ofdpaSrcMacLearnModeCfg_t"""
        this = _OFDPA_python.new_ofdpaSrcMacLearnModeCfg_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaSrcMacLearnModeCfg_t
    __del__ = lambda self : None;
ofdpaSrcMacLearnModeCfg_t_swigregister = _OFDPA_python.ofdpaSrcMacLearnModeCfg_t_swigregister
ofdpaSrcMacLearnModeCfg_t_swigregister(ofdpaSrcMacLearnModeCfg_t)

OFDPA_METER_RATE_KBPS = _OFDPA_python.OFDPA_METER_RATE_KBPS
OFDPA_METER_RATE_PKTPS = _OFDPA_python.OFDPA_METER_RATE_PKTPS
OFDPA_METER_COLOR_BLIND = _OFDPA_python.OFDPA_METER_COLOR_BLIND
OFDPA_METER_COLOR_AWARE = _OFDPA_python.OFDPA_METER_COLOR_AWARE
OFDPA_METER_TYPE_TCM = _OFDPA_python.OFDPA_METER_TYPE_TCM
OFDPA_TCM_METER_MODE_TRTCM = _OFDPA_python.OFDPA_TCM_METER_MODE_TRTCM
OFDPA_TCM_METER_MODE_SRTCM = _OFDPA_python.OFDPA_TCM_METER_MODE_SRTCM
OFDPA_TCM_METER_MODE_MOD_TRTCM = _OFDPA_python.OFDPA_TCM_METER_MODE_MOD_TRTCM
class ofdpaMeterParametersTcm_t(_object):
    """Proxy of C ofdpaMeterParametersTcm_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMeterParametersTcm_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMeterParametersTcm_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tcmMode"] = _OFDPA_python.ofdpaMeterParametersTcm_t_tcmMode_set
    __swig_getmethods__["tcmMode"] = _OFDPA_python.ofdpaMeterParametersTcm_t_tcmMode_get
    if _newclass:tcmMode = _swig_property(_OFDPA_python.ofdpaMeterParametersTcm_t_tcmMode_get, _OFDPA_python.ofdpaMeterParametersTcm_t_tcmMode_set)
    __swig_setmethods__["colorAwareMode"] = _OFDPA_python.ofdpaMeterParametersTcm_t_colorAwareMode_set
    __swig_getmethods__["colorAwareMode"] = _OFDPA_python.ofdpaMeterParametersTcm_t_colorAwareMode_get
    if _newclass:colorAwareMode = _swig_property(_OFDPA_python.ofdpaMeterParametersTcm_t_colorAwareMode_get, _OFDPA_python.ofdpaMeterParametersTcm_t_colorAwareMode_set)
    __swig_setmethods__["tcmRateUnit"] = _OFDPA_python.ofdpaMeterParametersTcm_t_tcmRateUnit_set
    __swig_getmethods__["tcmRateUnit"] = _OFDPA_python.ofdpaMeterParametersTcm_t_tcmRateUnit_get
    if _newclass:tcmRateUnit = _swig_property(_OFDPA_python.ofdpaMeterParametersTcm_t_tcmRateUnit_get, _OFDPA_python.ofdpaMeterParametersTcm_t_tcmRateUnit_set)
    __swig_setmethods__["yellowRate"] = _OFDPA_python.ofdpaMeterParametersTcm_t_yellowRate_set
    __swig_getmethods__["yellowRate"] = _OFDPA_python.ofdpaMeterParametersTcm_t_yellowRate_get
    if _newclass:yellowRate = _swig_property(_OFDPA_python.ofdpaMeterParametersTcm_t_yellowRate_get, _OFDPA_python.ofdpaMeterParametersTcm_t_yellowRate_set)
    __swig_setmethods__["yellowBurst"] = _OFDPA_python.ofdpaMeterParametersTcm_t_yellowBurst_set
    __swig_getmethods__["yellowBurst"] = _OFDPA_python.ofdpaMeterParametersTcm_t_yellowBurst_get
    if _newclass:yellowBurst = _swig_property(_OFDPA_python.ofdpaMeterParametersTcm_t_yellowBurst_get, _OFDPA_python.ofdpaMeterParametersTcm_t_yellowBurst_set)
    __swig_setmethods__["redRate"] = _OFDPA_python.ofdpaMeterParametersTcm_t_redRate_set
    __swig_getmethods__["redRate"] = _OFDPA_python.ofdpaMeterParametersTcm_t_redRate_get
    if _newclass:redRate = _swig_property(_OFDPA_python.ofdpaMeterParametersTcm_t_redRate_get, _OFDPA_python.ofdpaMeterParametersTcm_t_redRate_set)
    __swig_setmethods__["redBurst"] = _OFDPA_python.ofdpaMeterParametersTcm_t_redBurst_set
    __swig_getmethods__["redBurst"] = _OFDPA_python.ofdpaMeterParametersTcm_t_redBurst_get
    if _newclass:redBurst = _swig_property(_OFDPA_python.ofdpaMeterParametersTcm_t_redBurst_get, _OFDPA_python.ofdpaMeterParametersTcm_t_redBurst_set)
    def __init__(self): 
        """__init__(ofdpaMeterParametersTcm_s self) -> ofdpaMeterParametersTcm_t"""
        this = _OFDPA_python.new_ofdpaMeterParametersTcm_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMeterParametersTcm_t
    __del__ = lambda self : None;
ofdpaMeterParametersTcm_t_swigregister = _OFDPA_python.ofdpaMeterParametersTcm_t_swigregister
ofdpaMeterParametersTcm_t_swigregister(ofdpaMeterParametersTcm_t)

class ofdpaMeterEntry_t(_object):
    """Proxy of C ofdpaMeterEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMeterEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMeterEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["meterType"] = _OFDPA_python.ofdpaMeterEntry_t_meterType_set
    __swig_getmethods__["meterType"] = _OFDPA_python.ofdpaMeterEntry_t_meterType_get
    if _newclass:meterType = _swig_property(_OFDPA_python.ofdpaMeterEntry_t_meterType_get, _OFDPA_python.ofdpaMeterEntry_t_meterType_set)
    __swig_getmethods__["u"] = _OFDPA_python.ofdpaMeterEntry_t_u_get
    if _newclass:u = _swig_property(_OFDPA_python.ofdpaMeterEntry_t_u_get)
    def __init__(self): 
        """__init__(ofdpaMeterEntry_s self) -> ofdpaMeterEntry_t"""
        this = _OFDPA_python.new_ofdpaMeterEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMeterEntry_t
    __del__ = lambda self : None;
ofdpaMeterEntry_t_swigregister = _OFDPA_python.ofdpaMeterEntry_t_swigregister
ofdpaMeterEntry_t_swigregister(ofdpaMeterEntry_t)

class ofdpaMeterEntry_s_u(_object):
    """Proxy of C ofdpaMeterEntry_s_u struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMeterEntry_s_u, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMeterEntry_s_u, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tcmParameters"] = _OFDPA_python.ofdpaMeterEntry_s_u_tcmParameters_set
    __swig_getmethods__["tcmParameters"] = _OFDPA_python.ofdpaMeterEntry_s_u_tcmParameters_get
    if _newclass:tcmParameters = _swig_property(_OFDPA_python.ofdpaMeterEntry_s_u_tcmParameters_get, _OFDPA_python.ofdpaMeterEntry_s_u_tcmParameters_set)
    def __init__(self): 
        """__init__(ofdpaMeterEntry_s_u self) -> ofdpaMeterEntry_s_u"""
        this = _OFDPA_python.new_ofdpaMeterEntry_s_u()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMeterEntry_s_u
    __del__ = lambda self : None;
ofdpaMeterEntry_s_u_swigregister = _OFDPA_python.ofdpaMeterEntry_s_u_swigregister
ofdpaMeterEntry_s_u_swigregister(ofdpaMeterEntry_s_u)

class ofdpaMeterEntryStats_t(_object):
    """Proxy of C ofdpaMeterEntryStats_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMeterEntryStats_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMeterEntryStats_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaMeterEntryStats_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaMeterEntryStats_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaMeterEntryStats_t_refCount_get, _OFDPA_python.ofdpaMeterEntryStats_t_refCount_set)
    __swig_setmethods__["duration"] = _OFDPA_python.ofdpaMeterEntryStats_t_duration_set
    __swig_getmethods__["duration"] = _OFDPA_python.ofdpaMeterEntryStats_t_duration_get
    if _newclass:duration = _swig_property(_OFDPA_python.ofdpaMeterEntryStats_t_duration_get, _OFDPA_python.ofdpaMeterEntryStats_t_duration_set)
    def __init__(self): 
        """__init__(ofdpaMeterEntryStats_s self) -> ofdpaMeterEntryStats_t"""
        this = _OFDPA_python.new_ofdpaMeterEntryStats_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMeterEntryStats_t
    __del__ = lambda self : None;
ofdpaMeterEntryStats_t_swigregister = _OFDPA_python.ofdpaMeterEntryStats_t_swigregister
ofdpaMeterEntryStats_t_swigregister(ofdpaMeterEntryStats_t)

OFDPA_MEG_ID_LENGTH = _OFDPA_python.OFDPA_MEG_ID_LENGTH
OFDPA_LTR_EGRESS_ID_SIZE = _OFDPA_python.OFDPA_LTR_EGRESS_ID_SIZE
OFDPA_ORG_SPECIFIC_TLV_SIZE = _OFDPA_python.OFDPA_ORG_SPECIFIC_TLV_SIZE
OFDPA_ORG_SENDER_ID_TLV_SIZE = _OFDPA_python.OFDPA_ORG_SENDER_ID_TLV_SIZE
OFDPA_OAM_PM_FRAME_LEN_MIN = _OFDPA_python.OFDPA_OAM_PM_FRAME_LEN_MIN
OFDPA_OAM_PM_FRAME_LEN_MAX = _OFDPA_python.OFDPA_OAM_PM_FRAME_LEN_MAX
OFDPA_OAM_ICC_MIP_ID_LENGTH = _OFDPA_python.OFDPA_OAM_ICC_MIP_ID_LENGTH
OFDPA_MP_DIRECTION_DOWN = _OFDPA_python.OFDPA_MP_DIRECTION_DOWN
OFDPA_MP_DIRECTION_UP = _OFDPA_python.OFDPA_MP_DIRECTION_UP
OFDPA_CCM_INTERVAL_Invalid = _OFDPA_python.OFDPA_CCM_INTERVAL_Invalid
OFDPA_CCM_INTERVAL_300Hz = _OFDPA_python.OFDPA_CCM_INTERVAL_300Hz
OFDPA_CCM_INTERVAL_10ms = _OFDPA_python.OFDPA_CCM_INTERVAL_10ms
OFDPA_CCM_INTERVAL_100ms = _OFDPA_python.OFDPA_CCM_INTERVAL_100ms
OFDPA_CCM_INTERVAL_1s = _OFDPA_python.OFDPA_CCM_INTERVAL_1s
OFDPA_CCM_INTERVAL_10s = _OFDPA_python.OFDPA_CCM_INTERVAL_10s
OFDPA_CCM_INTERVAL_1min = _OFDPA_python.OFDPA_CCM_INTERVAL_1min
OFDPA_CCM_INTERVAL_10min = _OFDPA_python.OFDPA_CCM_INTERVAL_10min
OFDPA_OAM_MEG_TYPE_ETHERNET = _OFDPA_python.OFDPA_OAM_MEG_TYPE_ETHERNET
OFDPA_OAM_MEG_TYPE_G8113_1 = _OFDPA_python.OFDPA_OAM_MEG_TYPE_G8113_1
OFDPA_OAM_PM_TOOL_TYPE_CCM = _OFDPA_python.OFDPA_OAM_PM_TOOL_TYPE_CCM
OFDPA_OAM_PM_TOOL_TYPE_LM = _OFDPA_python.OFDPA_OAM_PM_TOOL_TYPE_LM
OFDPA_OAM_PM_TOOL_TYPE_SLM = _OFDPA_python.OFDPA_OAM_PM_TOOL_TYPE_SLM
OFDPA_OAM_MP_TYPE_MEP = _OFDPA_python.OFDPA_OAM_MP_TYPE_MEP
OFDPA_OAM_MP_TYPE_MIP = _OFDPA_python.OFDPA_OAM_MP_TYPE_MIP
OFDPA_OAM_PM_ROLE_INITIATOR = _OFDPA_python.OFDPA_OAM_PM_ROLE_INITIATOR
OFDPA_OAM_PM_ROLE_RESPONDER = _OFDPA_python.OFDPA_OAM_PM_ROLE_RESPONDER
OFDPA_OAM_PM_ROLE_BOTH = _OFDPA_python.OFDPA_OAM_PM_ROLE_BOTH
OFDPA_OAM_PM_STATE_STOPPED = _OFDPA_python.OFDPA_OAM_PM_STATE_STOPPED
OFDPA_OAM_PM_STATE_RUNNING = _OFDPA_python.OFDPA_OAM_PM_STATE_RUNNING
OFDPA_OAM_DM_TYPE_PROACTIVE = _OFDPA_python.OFDPA_OAM_DM_TYPE_PROACTIVE
OFDPA_OAM_DM_TYPE_ONDEMAND = _OFDPA_python.OFDPA_OAM_DM_TYPE_ONDEMAND
class ofdpaOamMegConfig_t(_object):
    """Proxy of C ofdpaOamMegConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamMegConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamMegConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["megType"] = _OFDPA_python.ofdpaOamMegConfig_t_megType_set
    __swig_getmethods__["megType"] = _OFDPA_python.ofdpaOamMegConfig_t_megType_get
    if _newclass:megType = _swig_property(_OFDPA_python.ofdpaOamMegConfig_t_megType_get, _OFDPA_python.ofdpaOamMegConfig_t_megType_set)
    __swig_setmethods__["megId"] = _OFDPA_python.ofdpaOamMegConfig_t_megId_set
    __swig_getmethods__["megId"] = _OFDPA_python.ofdpaOamMegConfig_t_megId_get
    if _newclass:megId = _swig_property(_OFDPA_python.ofdpaOamMegConfig_t_megId_get, _OFDPA_python.ofdpaOamMegConfig_t_megId_set)
    __swig_setmethods__["level"] = _OFDPA_python.ofdpaOamMegConfig_t_level_set
    __swig_getmethods__["level"] = _OFDPA_python.ofdpaOamMegConfig_t_level_get
    if _newclass:level = _swig_property(_OFDPA_python.ofdpaOamMegConfig_t_level_get, _OFDPA_python.ofdpaOamMegConfig_t_level_set)
    __swig_setmethods__["managedInstanceType"] = _OFDPA_python.ofdpaOamMegConfig_t_managedInstanceType_set
    __swig_getmethods__["managedInstanceType"] = _OFDPA_python.ofdpaOamMegConfig_t_managedInstanceType_get
    if _newclass:managedInstanceType = _swig_property(_OFDPA_python.ofdpaOamMegConfig_t_managedInstanceType_get, _OFDPA_python.ofdpaOamMegConfig_t_managedInstanceType_set)
    __swig_setmethods__["primVid"] = _OFDPA_python.ofdpaOamMegConfig_t_primVid_set
    __swig_getmethods__["primVid"] = _OFDPA_python.ofdpaOamMegConfig_t_primVid_get
    if _newclass:primVid = _swig_property(_OFDPA_python.ofdpaOamMegConfig_t_primVid_get, _OFDPA_python.ofdpaOamMegConfig_t_primVid_set)
    __swig_setmethods__["mipCreation"] = _OFDPA_python.ofdpaOamMegConfig_t_mipCreation_set
    __swig_getmethods__["mipCreation"] = _OFDPA_python.ofdpaOamMegConfig_t_mipCreation_get
    if _newclass:mipCreation = _swig_property(_OFDPA_python.ofdpaOamMegConfig_t_mipCreation_get, _OFDPA_python.ofdpaOamMegConfig_t_mipCreation_set)
    __swig_setmethods__["ccmInterval"] = _OFDPA_python.ofdpaOamMegConfig_t_ccmInterval_set
    __swig_getmethods__["ccmInterval"] = _OFDPA_python.ofdpaOamMegConfig_t_ccmInterval_get
    if _newclass:ccmInterval = _swig_property(_OFDPA_python.ofdpaOamMegConfig_t_ccmInterval_get, _OFDPA_python.ofdpaOamMegConfig_t_ccmInterval_set)
    def __init__(self): 
        """__init__(ofdpaOamMegConfig_s self) -> ofdpaOamMegConfig_t"""
        this = _OFDPA_python.new_ofdpaOamMegConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamMegConfig_t
    __del__ = lambda self : None;
ofdpaOamMegConfig_t_swigregister = _OFDPA_python.ofdpaOamMegConfig_t_swigregister
ofdpaOamMegConfig_t_swigregister(ofdpaOamMegConfig_t)

class ofdpaOamMegStatus_t(_object):
    """Proxy of C ofdpaOamMegStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamMegStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamMegStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaOamMegStatus_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaOamMegStatus_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaOamMegStatus_t_refCount_get, _OFDPA_python.ofdpaOamMegStatus_t_refCount_set)
    def __init__(self): 
        """__init__(ofdpaOamMegStatus_s self) -> ofdpaOamMegStatus_t"""
        this = _OFDPA_python.new_ofdpaOamMegStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamMegStatus_t
    __del__ = lambda self : None;
ofdpaOamMegStatus_t_swigregister = _OFDPA_python.ofdpaOamMegStatus_t_swigregister
ofdpaOamMegStatus_t_swigregister(ofdpaOamMegStatus_t)

OFDPA_MLP_ROLE_NONE = _OFDPA_python.OFDPA_MLP_ROLE_NONE
OFDPA_MLP_ROLE_PRIMARY = _OFDPA_python.OFDPA_MLP_ROLE_PRIMARY
OFDPA_MLP_ROLE_BACKUP = _OFDPA_python.OFDPA_MLP_ROLE_BACKUP
class mlpConfig_t(_object):
    """Proxy of C mlpConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, mlpConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, mlpConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mlpRole"] = _OFDPA_python.mlpConfig_t_mlpRole_set
    __swig_getmethods__["mlpRole"] = _OFDPA_python.mlpConfig_t_mlpRole_get
    if _newclass:mlpRole = _swig_property(_OFDPA_python.mlpConfig_t_mlpRole_get, _OFDPA_python.mlpConfig_t_mlpRole_set)
    __swig_getmethods__["u"] = _OFDPA_python.mlpConfig_t_u_get
    if _newclass:u = _swig_property(_OFDPA_python.mlpConfig_t_u_get)
    def __init__(self): 
        """__init__(mlpConfig_s self) -> mlpConfig_t"""
        this = _OFDPA_python.new_mlpConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_mlpConfig_t
    __del__ = lambda self : None;
mlpConfig_t_swigregister = _OFDPA_python.mlpConfig_t_swigregister
mlpConfig_t_swigregister(mlpConfig_t)

class mlpConfig_s_u(_object):
    """Proxy of C mlpConfig_s_u struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, mlpConfig_s_u, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, mlpConfig_s_u, name)
    __repr__ = _swig_repr
    __swig_setmethods__["livenessLogicalPortId"] = _OFDPA_python.mlpConfig_s_u_livenessLogicalPortId_set
    __swig_getmethods__["livenessLogicalPortId"] = _OFDPA_python.mlpConfig_s_u_livenessLogicalPortId_get
    if _newclass:livenessLogicalPortId = _swig_property(_OFDPA_python.mlpConfig_s_u_livenessLogicalPortId_get, _OFDPA_python.mlpConfig_s_u_livenessLogicalPortId_set)
    __swig_setmethods__["dropStatusId"] = _OFDPA_python.mlpConfig_s_u_dropStatusId_set
    __swig_getmethods__["dropStatusId"] = _OFDPA_python.mlpConfig_s_u_dropStatusId_get
    if _newclass:dropStatusId = _swig_property(_OFDPA_python.mlpConfig_s_u_dropStatusId_get, _OFDPA_python.mlpConfig_s_u_dropStatusId_set)
    def __init__(self): 
        """__init__(mlpConfig_s_u self) -> mlpConfig_s_u"""
        this = _OFDPA_python.new_mlpConfig_s_u()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_mlpConfig_s_u
    __del__ = lambda self : None;
mlpConfig_s_u_swigregister = _OFDPA_python.mlpConfig_s_u_swigregister
mlpConfig_s_u_swigregister(mlpConfig_s_u)

class ofdpaOamMepConfig_t(_object):
    """Proxy of C ofdpaOamMepConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamMepConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamMepConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["megIndex"] = _OFDPA_python.ofdpaOamMepConfig_t_megIndex_set
    __swig_getmethods__["megIndex"] = _OFDPA_python.ofdpaOamMepConfig_t_megIndex_get
    if _newclass:megIndex = _swig_property(_OFDPA_python.ofdpaOamMepConfig_t_megIndex_get, _OFDPA_python.ofdpaOamMepConfig_t_megIndex_set)
    __swig_setmethods__["mepId"] = _OFDPA_python.ofdpaOamMepConfig_t_mepId_set
    __swig_getmethods__["mepId"] = _OFDPA_python.ofdpaOamMepConfig_t_mepId_get
    if _newclass:mepId = _swig_property(_OFDPA_python.ofdpaOamMepConfig_t_mepId_get, _OFDPA_python.ofdpaOamMepConfig_t_mepId_set)
    __swig_setmethods__["ifIndex"] = _OFDPA_python.ofdpaOamMepConfig_t_ifIndex_set
    __swig_getmethods__["ifIndex"] = _OFDPA_python.ofdpaOamMepConfig_t_ifIndex_get
    if _newclass:ifIndex = _swig_property(_OFDPA_python.ofdpaOamMepConfig_t_ifIndex_get, _OFDPA_python.ofdpaOamMepConfig_t_ifIndex_set)
    __swig_setmethods__["direction"] = _OFDPA_python.ofdpaOamMepConfig_t_direction_set
    __swig_getmethods__["direction"] = _OFDPA_python.ofdpaOamMepConfig_t_direction_get
    if _newclass:direction = _swig_property(_OFDPA_python.ofdpaOamMepConfig_t_direction_get, _OFDPA_python.ofdpaOamMepConfig_t_direction_set)
    __swig_setmethods__["macAddress"] = _OFDPA_python.ofdpaOamMepConfig_t_macAddress_set
    __swig_getmethods__["macAddress"] = _OFDPA_python.ofdpaOamMepConfig_t_macAddress_get
    if _newclass:macAddress = _swig_property(_OFDPA_python.ofdpaOamMepConfig_t_macAddress_get, _OFDPA_python.ofdpaOamMepConfig_t_macAddress_set)
    __swig_setmethods__["ccmPriority"] = _OFDPA_python.ofdpaOamMepConfig_t_ccmPriority_set
    __swig_getmethods__["ccmPriority"] = _OFDPA_python.ofdpaOamMepConfig_t_ccmPriority_get
    if _newclass:ccmPriority = _swig_property(_OFDPA_python.ofdpaOamMepConfig_t_ccmPriority_get, _OFDPA_python.ofdpaOamMepConfig_t_ccmPriority_set)
    __swig_setmethods__["mlp"] = _OFDPA_python.ofdpaOamMepConfig_t_mlp_set
    __swig_getmethods__["mlp"] = _OFDPA_python.ofdpaOamMepConfig_t_mlp_get
    if _newclass:mlp = _swig_property(_OFDPA_python.ofdpaOamMepConfig_t_mlp_get, _OFDPA_python.ofdpaOamMepConfig_t_mlp_set)
    def __init__(self): 
        """__init__(ofdpaOamMepConfig_s self) -> ofdpaOamMepConfig_t"""
        this = _OFDPA_python.new_ofdpaOamMepConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamMepConfig_t
    __del__ = lambda self : None;
ofdpaOamMepConfig_t_swigregister = _OFDPA_python.ofdpaOamMepConfig_t_swigregister
ofdpaOamMepConfig_t_swigregister(ofdpaOamMepConfig_t)

class ofdpaOamMepStatus_t(_object):
    """Proxy of C ofdpaOamMepStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamMepStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamMepStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaOamMepStatus_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaOamMepStatus_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaOamMepStatus_t_refCount_get, _OFDPA_python.ofdpaOamMepStatus_t_refCount_set)
    __swig_setmethods__["ccmFramesSent"] = _OFDPA_python.ofdpaOamMepStatus_t_ccmFramesSent_set
    __swig_getmethods__["ccmFramesSent"] = _OFDPA_python.ofdpaOamMepStatus_t_ccmFramesSent_get
    if _newclass:ccmFramesSent = _swig_property(_OFDPA_python.ofdpaOamMepStatus_t_ccmFramesSent_get, _OFDPA_python.ofdpaOamMepStatus_t_ccmFramesSent_set)
    __swig_setmethods__["ccmFramesReceived"] = _OFDPA_python.ofdpaOamMepStatus_t_ccmFramesReceived_set
    __swig_getmethods__["ccmFramesReceived"] = _OFDPA_python.ofdpaOamMepStatus_t_ccmFramesReceived_get
    if _newclass:ccmFramesReceived = _swig_property(_OFDPA_python.ofdpaOamMepStatus_t_ccmFramesReceived_get, _OFDPA_python.ofdpaOamMepStatus_t_ccmFramesReceived_set)
    def __init__(self): 
        """__init__(ofdpaOamMepStatus_s self) -> ofdpaOamMepStatus_t"""
        this = _OFDPA_python.new_ofdpaOamMepStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamMepStatus_t
    __del__ = lambda self : None;
ofdpaOamMepStatus_t_swigregister = _OFDPA_python.ofdpaOamMepStatus_t_swigregister
ofdpaOamMepStatus_t_swigregister(ofdpaOamMepStatus_t)

class ofdpaOamMipConfig_t(_object):
    """Proxy of C ofdpaOamMipConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamMipConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamMipConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["megIndex"] = _OFDPA_python.ofdpaOamMipConfig_t_megIndex_set
    __swig_getmethods__["megIndex"] = _OFDPA_python.ofdpaOamMipConfig_t_megIndex_get
    if _newclass:megIndex = _swig_property(_OFDPA_python.ofdpaOamMipConfig_t_megIndex_get, _OFDPA_python.ofdpaOamMipConfig_t_megIndex_set)
    __swig_setmethods__["ifIndex"] = _OFDPA_python.ofdpaOamMipConfig_t_ifIndex_set
    __swig_getmethods__["ifIndex"] = _OFDPA_python.ofdpaOamMipConfig_t_ifIndex_get
    if _newclass:ifIndex = _swig_property(_OFDPA_python.ofdpaOamMipConfig_t_ifIndex_get, _OFDPA_python.ofdpaOamMipConfig_t_ifIndex_set)
    __swig_setmethods__["direction"] = _OFDPA_python.ofdpaOamMipConfig_t_direction_set
    __swig_getmethods__["direction"] = _OFDPA_python.ofdpaOamMipConfig_t_direction_get
    if _newclass:direction = _swig_property(_OFDPA_python.ofdpaOamMipConfig_t_direction_get, _OFDPA_python.ofdpaOamMipConfig_t_direction_set)
    __swig_setmethods__["mipIdTlvData"] = _OFDPA_python.ofdpaOamMipConfig_t_mipIdTlvData_set
    __swig_getmethods__["mipIdTlvData"] = _OFDPA_python.ofdpaOamMipConfig_t_mipIdTlvData_get
    if _newclass:mipIdTlvData = _swig_property(_OFDPA_python.ofdpaOamMipConfig_t_mipIdTlvData_get, _OFDPA_python.ofdpaOamMipConfig_t_mipIdTlvData_set)
    __swig_setmethods__["macAddress"] = _OFDPA_python.ofdpaOamMipConfig_t_macAddress_set
    __swig_getmethods__["macAddress"] = _OFDPA_python.ofdpaOamMipConfig_t_macAddress_get
    if _newclass:macAddress = _swig_property(_OFDPA_python.ofdpaOamMipConfig_t_macAddress_get, _OFDPA_python.ofdpaOamMipConfig_t_macAddress_set)
    def __init__(self): 
        """__init__(ofdpaOamMipConfig_s self) -> ofdpaOamMipConfig_t"""
        this = _OFDPA_python.new_ofdpaOamMipConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamMipConfig_t
    __del__ = lambda self : None;
ofdpaOamMipConfig_t_swigregister = _OFDPA_python.ofdpaOamMipConfig_t_swigregister
ofdpaOamMipConfig_t_swigregister(ofdpaOamMipConfig_t)

class ofdpaOamMipStatus_t(_object):
    """Proxy of C ofdpaOamMipStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamMipStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamMipStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaOamMipStatus_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaOamMipStatus_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaOamMipStatus_t_refCount_get, _OFDPA_python.ofdpaOamMipStatus_t_refCount_set)
    def __init__(self): 
        """__init__(ofdpaOamMipStatus_s self) -> ofdpaOamMipStatus_t"""
        this = _OFDPA_python.new_ofdpaOamMipStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamMipStatus_t
    __del__ = lambda self : None;
ofdpaOamMipStatus_t_swigregister = _OFDPA_python.ofdpaOamMipStatus_t_swigregister
ofdpaOamMipStatus_t_swigregister(ofdpaOamMipStatus_t)

class ofdpaOamRemoteMpConfig_t(_object):
    """Proxy of C ofdpaOamRemoteMpConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamRemoteMpConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamRemoteMpConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaOamRemoteMpConfig_t_lmepId_get, _OFDPA_python.ofdpaOamRemoteMpConfig_t_lmepId_set)
    __swig_setmethods__["rmpType"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_rmpType_set
    __swig_getmethods__["rmpType"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_rmpType_get
    if _newclass:rmpType = _swig_property(_OFDPA_python.ofdpaOamRemoteMpConfig_t_rmpType_get, _OFDPA_python.ofdpaOamRemoteMpConfig_t_rmpType_set)
    __swig_setmethods__["mepId"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_mepId_set
    __swig_getmethods__["mepId"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_mepId_get
    if _newclass:mepId = _swig_property(_OFDPA_python.ofdpaOamRemoteMpConfig_t_mepId_get, _OFDPA_python.ofdpaOamRemoteMpConfig_t_mepId_set)
    __swig_setmethods__["mipIdTlvData"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_mipIdTlvData_set
    __swig_getmethods__["mipIdTlvData"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_mipIdTlvData_get
    if _newclass:mipIdTlvData = _swig_property(_OFDPA_python.ofdpaOamRemoteMpConfig_t_mipIdTlvData_get, _OFDPA_python.ofdpaOamRemoteMpConfig_t_mipIdTlvData_set)
    __swig_setmethods__["ttlToMip"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_ttlToMip_set
    __swig_getmethods__["ttlToMip"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_ttlToMip_get
    if _newclass:ttlToMip = _swig_property(_OFDPA_python.ofdpaOamRemoteMpConfig_t_ttlToMip_get, _OFDPA_python.ofdpaOamRemoteMpConfig_t_ttlToMip_set)
    __swig_setmethods__["macAddress"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_macAddress_set
    __swig_getmethods__["macAddress"] = _OFDPA_python.ofdpaOamRemoteMpConfig_t_macAddress_get
    if _newclass:macAddress = _swig_property(_OFDPA_python.ofdpaOamRemoteMpConfig_t_macAddress_get, _OFDPA_python.ofdpaOamRemoteMpConfig_t_macAddress_set)
    def __init__(self): 
        """__init__(ofdpaOamRemoteMpConfig_s self) -> ofdpaOamRemoteMpConfig_t"""
        this = _OFDPA_python.new_ofdpaOamRemoteMpConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamRemoteMpConfig_t
    __del__ = lambda self : None;
ofdpaOamRemoteMpConfig_t_swigregister = _OFDPA_python.ofdpaOamRemoteMpConfig_t_swigregister
ofdpaOamRemoteMpConfig_t_swigregister(ofdpaOamRemoteMpConfig_t)

OFDPA_OAM_LB_TEST_TLV_NULL = _OFDPA_python.OFDPA_OAM_LB_TEST_TLV_NULL
OFDPA_OAM_LB_TEST_TLV_NULL_CRC32 = _OFDPA_python.OFDPA_OAM_LB_TEST_TLV_NULL_CRC32
OFDPA_OAM_LB_TEST_TLV_PRBS = _OFDPA_python.OFDPA_OAM_LB_TEST_TLV_PRBS
OFDPA_OAM_LB_TEST_TLV_PRBS_CRC32 = _OFDPA_python.OFDPA_OAM_LB_TEST_TLV_PRBS_CRC32
OFDPA_OAM_LB_DISCOVERY_NONE = _OFDPA_python.OFDPA_OAM_LB_DISCOVERY_NONE
OFDPA_OAM_LB_DISCOVERY_INGRESS = _OFDPA_python.OFDPA_OAM_LB_DISCOVERY_INGRESS
OFDPA_OAM_LB_DISCOVERY_EGRESS = _OFDPA_python.OFDPA_OAM_LB_DISCOVERY_EGRESS
OFDPA_OAM_LB_DISCOVERY_ICC_MEPID = _OFDPA_python.OFDPA_OAM_LB_DISCOVERY_ICC_MEPID
OFDPA_OAM_LB_DISCOVERY_ICC_MIPID = _OFDPA_python.OFDPA_OAM_LB_DISCOVERY_ICC_MIPID
OFDPA_OAM_LB_DISCOVERY_RESERVED = _OFDPA_python.OFDPA_OAM_LB_DISCOVERY_RESERVED
class ofdpaOamLbConfig_t(_object):
    """Proxy of C ofdpaOamLbConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamLbConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamLbConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lbDestMpId"] = _OFDPA_python.ofdpaOamLbConfig_t_lbDestMpId_set
    __swig_getmethods__["lbDestMpId"] = _OFDPA_python.ofdpaOamLbConfig_t_lbDestMpId_get
    if _newclass:lbDestMpId = _swig_property(_OFDPA_python.ofdpaOamLbConfig_t_lbDestMpId_get, _OFDPA_python.ofdpaOamLbConfig_t_lbDestMpId_set)
    __swig_setmethods__["lbPeriod"] = _OFDPA_python.ofdpaOamLbConfig_t_lbPeriod_set
    __swig_getmethods__["lbPeriod"] = _OFDPA_python.ofdpaOamLbConfig_t_lbPeriod_get
    if _newclass:lbPeriod = _swig_property(_OFDPA_python.ofdpaOamLbConfig_t_lbPeriod_get, _OFDPA_python.ofdpaOamLbConfig_t_lbPeriod_set)
    __swig_setmethods__["lbPriority"] = _OFDPA_python.ofdpaOamLbConfig_t_lbPriority_set
    __swig_getmethods__["lbPriority"] = _OFDPA_python.ofdpaOamLbConfig_t_lbPriority_get
    if _newclass:lbPriority = _swig_property(_OFDPA_python.ofdpaOamLbConfig_t_lbPriority_get, _OFDPA_python.ofdpaOamLbConfig_t_lbPriority_set)
    __swig_setmethods__["lbDropEligibility"] = _OFDPA_python.ofdpaOamLbConfig_t_lbDropEligibility_set
    __swig_getmethods__["lbDropEligibility"] = _OFDPA_python.ofdpaOamLbConfig_t_lbDropEligibility_get
    if _newclass:lbDropEligibility = _swig_property(_OFDPA_python.ofdpaOamLbConfig_t_lbDropEligibility_get, _OFDPA_python.ofdpaOamLbConfig_t_lbDropEligibility_set)
    __swig_setmethods__["lbNbrPacketsToSend"] = _OFDPA_python.ofdpaOamLbConfig_t_lbNbrPacketsToSend_set
    __swig_getmethods__["lbNbrPacketsToSend"] = _OFDPA_python.ofdpaOamLbConfig_t_lbNbrPacketsToSend_get
    if _newclass:lbNbrPacketsToSend = _swig_property(_OFDPA_python.ofdpaOamLbConfig_t_lbNbrPacketsToSend_get, _OFDPA_python.ofdpaOamLbConfig_t_lbNbrPacketsToSend_set)
    __swig_setmethods__["lbPacketLength"] = _OFDPA_python.ofdpaOamLbConfig_t_lbPacketLength_set
    __swig_getmethods__["lbPacketLength"] = _OFDPA_python.ofdpaOamLbConfig_t_lbPacketLength_get
    if _newclass:lbPacketLength = _swig_property(_OFDPA_python.ofdpaOamLbConfig_t_lbPacketLength_get, _OFDPA_python.ofdpaOamLbConfig_t_lbPacketLength_set)
    __swig_setmethods__["lbTestPatternTlvPresent"] = _OFDPA_python.ofdpaOamLbConfig_t_lbTestPatternTlvPresent_set
    __swig_getmethods__["lbTestPatternTlvPresent"] = _OFDPA_python.ofdpaOamLbConfig_t_lbTestPatternTlvPresent_get
    if _newclass:lbTestPatternTlvPresent = _swig_property(_OFDPA_python.ofdpaOamLbConfig_t_lbTestPatternTlvPresent_get, _OFDPA_python.ofdpaOamLbConfig_t_lbTestPatternTlvPresent_set)
    __swig_setmethods__["lbTestPatternTlvType"] = _OFDPA_python.ofdpaOamLbConfig_t_lbTestPatternTlvType_set
    __swig_getmethods__["lbTestPatternTlvType"] = _OFDPA_python.ofdpaOamLbConfig_t_lbTestPatternTlvType_get
    if _newclass:lbTestPatternTlvType = _swig_property(_OFDPA_python.ofdpaOamLbConfig_t_lbTestPatternTlvType_get, _OFDPA_python.ofdpaOamLbConfig_t_lbTestPatternTlvType_set)
    __swig_setmethods__["lbDiscovery"] = _OFDPA_python.ofdpaOamLbConfig_t_lbDiscovery_set
    __swig_getmethods__["lbDiscovery"] = _OFDPA_python.ofdpaOamLbConfig_t_lbDiscovery_get
    if _newclass:lbDiscovery = _swig_property(_OFDPA_python.ofdpaOamLbConfig_t_lbDiscovery_get, _OFDPA_python.ofdpaOamLbConfig_t_lbDiscovery_set)
    __swig_setmethods__["lbTtl"] = _OFDPA_python.ofdpaOamLbConfig_t_lbTtl_set
    __swig_getmethods__["lbTtl"] = _OFDPA_python.ofdpaOamLbConfig_t_lbTtl_get
    if _newclass:lbTtl = _swig_property(_OFDPA_python.ofdpaOamLbConfig_t_lbTtl_get, _OFDPA_python.ofdpaOamLbConfig_t_lbTtl_set)
    def __init__(self): 
        """__init__(ofdpaOamLbConfig_s self) -> ofdpaOamLbConfig_t"""
        this = _OFDPA_python.new_ofdpaOamLbConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamLbConfig_t
    __del__ = lambda self : None;
ofdpaOamLbConfig_t_swigregister = _OFDPA_python.ofdpaOamLbConfig_t_swigregister
ofdpaOamLbConfig_t_swigregister(ofdpaOamLbConfig_t)

class ofdpaOamLbStatus_t(_object):
    """Proxy of C ofdpaOamLbStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamLbStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamLbStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lbResultOk"] = _OFDPA_python.ofdpaOamLbStatus_t_lbResultOk_set
    __swig_getmethods__["lbResultOk"] = _OFDPA_python.ofdpaOamLbStatus_t_lbResultOk_get
    if _newclass:lbResultOk = _swig_property(_OFDPA_python.ofdpaOamLbStatus_t_lbResultOk_get, _OFDPA_python.ofdpaOamLbStatus_t_lbResultOk_set)
    __swig_setmethods__["lbrIn"] = _OFDPA_python.ofdpaOamLbStatus_t_lbrIn_set
    __swig_getmethods__["lbrIn"] = _OFDPA_python.ofdpaOamLbStatus_t_lbrIn_get
    if _newclass:lbrIn = _swig_property(_OFDPA_python.ofdpaOamLbStatus_t_lbrIn_get, _OFDPA_python.ofdpaOamLbStatus_t_lbrIn_set)
    __swig_setmethods__["lbrInOutOfOrder"] = _OFDPA_python.ofdpaOamLbStatus_t_lbrInOutOfOrder_set
    __swig_getmethods__["lbrInOutOfOrder"] = _OFDPA_python.ofdpaOamLbStatus_t_lbrInOutOfOrder_get
    if _newclass:lbrInOutOfOrder = _swig_property(_OFDPA_python.ofdpaOamLbStatus_t_lbrInOutOfOrder_get, _OFDPA_python.ofdpaOamLbStatus_t_lbrInOutOfOrder_set)
    __swig_setmethods__["lbrBadMsdu"] = _OFDPA_python.ofdpaOamLbStatus_t_lbrBadMsdu_set
    __swig_getmethods__["lbrBadMsdu"] = _OFDPA_python.ofdpaOamLbStatus_t_lbrBadMsdu_get
    if _newclass:lbrBadMsdu = _swig_property(_OFDPA_python.ofdpaOamLbStatus_t_lbrBadMsdu_get, _OFDPA_python.ofdpaOamLbStatus_t_lbrBadMsdu_set)
    def __init__(self): 
        """__init__(ofdpaOamLbStatus_s self) -> ofdpaOamLbStatus_t"""
        this = _OFDPA_python.new_ofdpaOamLbStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamLbStatus_t
    __del__ = lambda self : None;
ofdpaOamLbStatus_t_swigregister = _OFDPA_python.ofdpaOamLbStatus_t_swigregister
ofdpaOamLbStatus_t_swigregister(ofdpaOamLbStatus_t)

class ofdpaOamLckConfig_t(_object):
    """Proxy of C ofdpaOamLckConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamLckConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamLckConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lckClientMegLevel"] = _OFDPA_python.ofdpaOamLckConfig_t_lckClientMegLevel_set
    __swig_getmethods__["lckClientMegLevel"] = _OFDPA_python.ofdpaOamLckConfig_t_lckClientMegLevel_get
    if _newclass:lckClientMegLevel = _swig_property(_OFDPA_python.ofdpaOamLckConfig_t_lckClientMegLevel_get, _OFDPA_python.ofdpaOamLckConfig_t_lckClientMegLevel_set)
    __swig_setmethods__["lckPeriod"] = _OFDPA_python.ofdpaOamLckConfig_t_lckPeriod_set
    __swig_getmethods__["lckPeriod"] = _OFDPA_python.ofdpaOamLckConfig_t_lckPeriod_get
    if _newclass:lckPeriod = _swig_property(_OFDPA_python.ofdpaOamLckConfig_t_lckPeriod_get, _OFDPA_python.ofdpaOamLckConfig_t_lckPeriod_set)
    __swig_setmethods__["lckTrafficClass"] = _OFDPA_python.ofdpaOamLckConfig_t_lckTrafficClass_set
    __swig_getmethods__["lckTrafficClass"] = _OFDPA_python.ofdpaOamLckConfig_t_lckTrafficClass_get
    if _newclass:lckTrafficClass = _swig_property(_OFDPA_python.ofdpaOamLckConfig_t_lckTrafficClass_get, _OFDPA_python.ofdpaOamLckConfig_t_lckTrafficClass_set)
    def __init__(self): 
        """__init__(ofdpaOamLckConfig_s self) -> ofdpaOamLckConfig_t"""
        this = _OFDPA_python.new_ofdpaOamLckConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamLckConfig_t
    __del__ = lambda self : None;
ofdpaOamLckConfig_t_swigregister = _OFDPA_python.ofdpaOamLckConfig_t_swigregister
ofdpaOamLckConfig_t_swigregister(ofdpaOamLckConfig_t)

class ofdpaOamAisConfig_t(_object):
    """Proxy of C ofdpaOamAisConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamAisConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamAisConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["aisClientMegLevel"] = _OFDPA_python.ofdpaOamAisConfig_t_aisClientMegLevel_set
    __swig_getmethods__["aisClientMegLevel"] = _OFDPA_python.ofdpaOamAisConfig_t_aisClientMegLevel_get
    if _newclass:aisClientMegLevel = _swig_property(_OFDPA_python.ofdpaOamAisConfig_t_aisClientMegLevel_get, _OFDPA_python.ofdpaOamAisConfig_t_aisClientMegLevel_set)
    __swig_setmethods__["aisPeriod"] = _OFDPA_python.ofdpaOamAisConfig_t_aisPeriod_set
    __swig_getmethods__["aisPeriod"] = _OFDPA_python.ofdpaOamAisConfig_t_aisPeriod_get
    if _newclass:aisPeriod = _swig_property(_OFDPA_python.ofdpaOamAisConfig_t_aisPeriod_get, _OFDPA_python.ofdpaOamAisConfig_t_aisPeriod_set)
    __swig_setmethods__["aisPriority"] = _OFDPA_python.ofdpaOamAisConfig_t_aisPriority_set
    __swig_getmethods__["aisPriority"] = _OFDPA_python.ofdpaOamAisConfig_t_aisPriority_get
    if _newclass:aisPriority = _swig_property(_OFDPA_python.ofdpaOamAisConfig_t_aisPriority_get, _OFDPA_python.ofdpaOamAisConfig_t_aisPriority_set)
    def __init__(self): 
        """__init__(ofdpaOamAisConfig_s self) -> ofdpaOamAisConfig_t"""
        this = _OFDPA_python.new_ofdpaOamAisConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamAisConfig_t
    __del__ = lambda self : None;
ofdpaOamAisConfig_t_swigregister = _OFDPA_python.ofdpaOamAisConfig_t_swigregister
ofdpaOamAisConfig_t_swigregister(ofdpaOamAisConfig_t)

class ofdpaOamCsfConfig_t(_object):
    """Proxy of C ofdpaOamCsfConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamCsfConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamCsfConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["csfPeriod"] = _OFDPA_python.ofdpaOamCsfConfig_t_csfPeriod_set
    __swig_getmethods__["csfPeriod"] = _OFDPA_python.ofdpaOamCsfConfig_t_csfPeriod_get
    if _newclass:csfPeriod = _swig_property(_OFDPA_python.ofdpaOamCsfConfig_t_csfPeriod_get, _OFDPA_python.ofdpaOamCsfConfig_t_csfPeriod_set)
    __swig_setmethods__["csfPriority"] = _OFDPA_python.ofdpaOamCsfConfig_t_csfPriority_set
    __swig_getmethods__["csfPriority"] = _OFDPA_python.ofdpaOamCsfConfig_t_csfPriority_get
    if _newclass:csfPriority = _swig_property(_OFDPA_python.ofdpaOamCsfConfig_t_csfPriority_get, _OFDPA_python.ofdpaOamCsfConfig_t_csfPriority_set)
    def __init__(self): 
        """__init__(ofdpaOamCsfConfig_s self) -> ofdpaOamCsfConfig_t"""
        this = _OFDPA_python.new_ofdpaOamCsfConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamCsfConfig_t
    __del__ = lambda self : None;
ofdpaOamCsfConfig_t_swigregister = _OFDPA_python.ofdpaOamCsfConfig_t_swigregister
ofdpaOamCsfConfig_t_swigregister(ofdpaOamCsfConfig_t)

class ofdpaOamLtConfig_t(_object):
    """Proxy of C ofdpaOamLtConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamLtConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamLtConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ltDestMpId"] = _OFDPA_python.ofdpaOamLtConfig_t_ltDestMpId_set
    __swig_getmethods__["ltDestMpId"] = _OFDPA_python.ofdpaOamLtConfig_t_ltDestMpId_get
    if _newclass:ltDestMpId = _swig_property(_OFDPA_python.ofdpaOamLtConfig_t_ltDestMpId_get, _OFDPA_python.ofdpaOamLtConfig_t_ltDestMpId_set)
    __swig_setmethods__["ltPriority"] = _OFDPA_python.ofdpaOamLtConfig_t_ltPriority_set
    __swig_getmethods__["ltPriority"] = _OFDPA_python.ofdpaOamLtConfig_t_ltPriority_get
    if _newclass:ltPriority = _swig_property(_OFDPA_python.ofdpaOamLtConfig_t_ltPriority_get, _OFDPA_python.ofdpaOamLtConfig_t_ltPriority_set)
    __swig_setmethods__["ltTtl"] = _OFDPA_python.ofdpaOamLtConfig_t_ltTtl_set
    __swig_getmethods__["ltTtl"] = _OFDPA_python.ofdpaOamLtConfig_t_ltTtl_get
    if _newclass:ltTtl = _swig_property(_OFDPA_python.ofdpaOamLtConfig_t_ltTtl_get, _OFDPA_python.ofdpaOamLtConfig_t_ltTtl_set)
    def __init__(self): 
        """__init__(ofdpaOamLtConfig_s self) -> ofdpaOamLtConfig_t"""
        this = _OFDPA_python.new_ofdpaOamLtConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamLtConfig_t
    __del__ = lambda self : None;
ofdpaOamLtConfig_t_swigregister = _OFDPA_python.ofdpaOamLtConfig_t_swigregister
ofdpaOamLtConfig_t_swigregister(ofdpaOamLtConfig_t)

class ofdpaOamLtStatus_t(_object):
    """Proxy of C ofdpaOamLtStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamLtStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamLtStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ltResultOK"] = _OFDPA_python.ofdpaOamLtStatus_t_ltResultOK_set
    __swig_getmethods__["ltResultOK"] = _OFDPA_python.ofdpaOamLtStatus_t_ltResultOK_get
    if _newclass:ltResultOK = _swig_property(_OFDPA_python.ofdpaOamLtStatus_t_ltResultOK_get, _OFDPA_python.ofdpaOamLtStatus_t_ltResultOK_set)
    __swig_setmethods__["ltUnexpLtrIn"] = _OFDPA_python.ofdpaOamLtStatus_t_ltUnexpLtrIn_set
    __swig_getmethods__["ltUnexpLtrIn"] = _OFDPA_python.ofdpaOamLtStatus_t_ltUnexpLtrIn_get
    if _newclass:ltUnexpLtrIn = _swig_property(_OFDPA_python.ofdpaOamLtStatus_t_ltUnexpLtrIn_get, _OFDPA_python.ofdpaOamLtStatus_t_ltUnexpLtrIn_set)
    def __init__(self): 
        """__init__(ofdpaOamLtStatus_s self) -> ofdpaOamLtStatus_t"""
        this = _OFDPA_python.new_ofdpaOamLtStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamLtStatus_t
    __del__ = lambda self : None;
ofdpaOamLtStatus_t_swigregister = _OFDPA_python.ofdpaOamLtStatus_t_swigregister
ofdpaOamLtStatus_t_swigregister(ofdpaOamLtStatus_t)

OFDPA_OAM_RMEP_STATE_IDLE = _OFDPA_python.OFDPA_OAM_RMEP_STATE_IDLE
OFDPA_OAM_RMEP_STATE_START = _OFDPA_python.OFDPA_OAM_RMEP_STATE_START
OFDPA_OAM_RMEP_STATE_FAILED = _OFDPA_python.OFDPA_OAM_RMEP_STATE_FAILED
OFDPA_OAM_RMEP_STATE_OK = _OFDPA_python.OFDPA_OAM_RMEP_STATE_OK
class ofdpaOamCcmDatabaseEntry_t(_object):
    """Proxy of C ofdpaOamCcmDatabaseEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamCcmDatabaseEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamCcmDatabaseEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["remoteMepState"] = _OFDPA_python.ofdpaOamCcmDatabaseEntry_t_remoteMepState_set
    __swig_getmethods__["remoteMepState"] = _OFDPA_python.ofdpaOamCcmDatabaseEntry_t_remoteMepState_get
    if _newclass:remoteMepState = _swig_property(_OFDPA_python.ofdpaOamCcmDatabaseEntry_t_remoteMepState_get, _OFDPA_python.ofdpaOamCcmDatabaseEntry_t_remoteMepState_set)
    __swig_setmethods__["remoteMepMacAddr"] = _OFDPA_python.ofdpaOamCcmDatabaseEntry_t_remoteMepMacAddr_set
    __swig_getmethods__["remoteMepMacAddr"] = _OFDPA_python.ofdpaOamCcmDatabaseEntry_t_remoteMepMacAddr_get
    if _newclass:remoteMepMacAddr = _swig_property(_OFDPA_python.ofdpaOamCcmDatabaseEntry_t_remoteMepMacAddr_get, _OFDPA_python.ofdpaOamCcmDatabaseEntry_t_remoteMepMacAddr_set)
    __swig_setmethods__["lastUpdateTime"] = _OFDPA_python.ofdpaOamCcmDatabaseEntry_t_lastUpdateTime_set
    __swig_getmethods__["lastUpdateTime"] = _OFDPA_python.ofdpaOamCcmDatabaseEntry_t_lastUpdateTime_get
    if _newclass:lastUpdateTime = _swig_property(_OFDPA_python.ofdpaOamCcmDatabaseEntry_t_lastUpdateTime_get, _OFDPA_python.ofdpaOamCcmDatabaseEntry_t_lastUpdateTime_set)
    def __init__(self): 
        """__init__(ofdpaOamCcmDatabaseEntry_s self) -> ofdpaOamCcmDatabaseEntry_t"""
        this = _OFDPA_python.new_ofdpaOamCcmDatabaseEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamCcmDatabaseEntry_t
    __del__ = lambda self : None;
ofdpaOamCcmDatabaseEntry_t_swigregister = _OFDPA_python.ofdpaOamCcmDatabaseEntry_t_swigregister
ofdpaOamCcmDatabaseEntry_t_swigregister(ofdpaOamCcmDatabaseEntry_t)

class ofdpaOamLtrEntry_t(_object):
    """Proxy of C ofdpaOamLtrEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamLtrEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamLtrEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ttl"] = _OFDPA_python.ofdpaOamLtrEntry_t_ttl_set
    __swig_getmethods__["ttl"] = _OFDPA_python.ofdpaOamLtrEntry_t_ttl_get
    if _newclass:ttl = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_ttl_get, _OFDPA_python.ofdpaOamLtrEntry_t_ttl_set)
    __swig_setmethods__["forwarded"] = _OFDPA_python.ofdpaOamLtrEntry_t_forwarded_set
    __swig_getmethods__["forwarded"] = _OFDPA_python.ofdpaOamLtrEntry_t_forwarded_get
    if _newclass:forwarded = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_forwarded_get, _OFDPA_python.ofdpaOamLtrEntry_t_forwarded_set)
    __swig_setmethods__["terminalMep"] = _OFDPA_python.ofdpaOamLtrEntry_t_terminalMep_set
    __swig_getmethods__["terminalMep"] = _OFDPA_python.ofdpaOamLtrEntry_t_terminalMep_get
    if _newclass:terminalMep = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_terminalMep_get, _OFDPA_python.ofdpaOamLtrEntry_t_terminalMep_set)
    __swig_setmethods__["lastEgressId"] = _OFDPA_python.ofdpaOamLtrEntry_t_lastEgressId_set
    __swig_getmethods__["lastEgressId"] = _OFDPA_python.ofdpaOamLtrEntry_t_lastEgressId_get
    if _newclass:lastEgressId = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_lastEgressId_get, _OFDPA_python.ofdpaOamLtrEntry_t_lastEgressId_set)
    __swig_setmethods__["nextEgressId"] = _OFDPA_python.ofdpaOamLtrEntry_t_nextEgressId_set
    __swig_getmethods__["nextEgressId"] = _OFDPA_python.ofdpaOamLtrEntry_t_nextEgressId_get
    if _newclass:nextEgressId = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_nextEgressId_get, _OFDPA_python.ofdpaOamLtrEntry_t_nextEgressId_set)
    __swig_setmethods__["relayAction"] = _OFDPA_python.ofdpaOamLtrEntry_t_relayAction_set
    __swig_getmethods__["relayAction"] = _OFDPA_python.ofdpaOamLtrEntry_t_relayAction_get
    if _newclass:relayAction = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_relayAction_get, _OFDPA_python.ofdpaOamLtrEntry_t_relayAction_set)
    __swig_setmethods__["ingressAction"] = _OFDPA_python.ofdpaOamLtrEntry_t_ingressAction_set
    __swig_getmethods__["ingressAction"] = _OFDPA_python.ofdpaOamLtrEntry_t_ingressAction_get
    if _newclass:ingressAction = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_ingressAction_get, _OFDPA_python.ofdpaOamLtrEntry_t_ingressAction_set)
    __swig_setmethods__["ingressMac"] = _OFDPA_python.ofdpaOamLtrEntry_t_ingressMac_set
    __swig_getmethods__["ingressMac"] = _OFDPA_python.ofdpaOamLtrEntry_t_ingressMac_get
    if _newclass:ingressMac = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_ingressMac_get, _OFDPA_python.ofdpaOamLtrEntry_t_ingressMac_set)
    __swig_setmethods__["ingressPortIdSubtype"] = _OFDPA_python.ofdpaOamLtrEntry_t_ingressPortIdSubtype_set
    __swig_getmethods__["ingressPortIdSubtype"] = _OFDPA_python.ofdpaOamLtrEntry_t_ingressPortIdSubtype_get
    if _newclass:ingressPortIdSubtype = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_ingressPortIdSubtype_get, _OFDPA_python.ofdpaOamLtrEntry_t_ingressPortIdSubtype_set)
    __swig_setmethods__["ingressPortId"] = _OFDPA_python.ofdpaOamLtrEntry_t_ingressPortId_set
    __swig_getmethods__["ingressPortId"] = _OFDPA_python.ofdpaOamLtrEntry_t_ingressPortId_get
    if _newclass:ingressPortId = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_ingressPortId_get, _OFDPA_python.ofdpaOamLtrEntry_t_ingressPortId_set)
    __swig_setmethods__["egressAction"] = _OFDPA_python.ofdpaOamLtrEntry_t_egressAction_set
    __swig_getmethods__["egressAction"] = _OFDPA_python.ofdpaOamLtrEntry_t_egressAction_get
    if _newclass:egressAction = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_egressAction_get, _OFDPA_python.ofdpaOamLtrEntry_t_egressAction_set)
    __swig_setmethods__["egressMac"] = _OFDPA_python.ofdpaOamLtrEntry_t_egressMac_set
    __swig_getmethods__["egressMac"] = _OFDPA_python.ofdpaOamLtrEntry_t_egressMac_get
    if _newclass:egressMac = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_egressMac_get, _OFDPA_python.ofdpaOamLtrEntry_t_egressMac_set)
    __swig_setmethods__["egressPortIdSubtype"] = _OFDPA_python.ofdpaOamLtrEntry_t_egressPortIdSubtype_set
    __swig_getmethods__["egressPortIdSubtype"] = _OFDPA_python.ofdpaOamLtrEntry_t_egressPortIdSubtype_get
    if _newclass:egressPortIdSubtype = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_egressPortIdSubtype_get, _OFDPA_python.ofdpaOamLtrEntry_t_egressPortIdSubtype_set)
    __swig_setmethods__["egressPortId"] = _OFDPA_python.ofdpaOamLtrEntry_t_egressPortId_set
    __swig_getmethods__["egressPortId"] = _OFDPA_python.ofdpaOamLtrEntry_t_egressPortId_get
    if _newclass:egressPortId = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_egressPortId_get, _OFDPA_python.ofdpaOamLtrEntry_t_egressPortId_set)
    __swig_setmethods__["organizationSpecificTlv"] = _OFDPA_python.ofdpaOamLtrEntry_t_organizationSpecificTlv_set
    __swig_getmethods__["organizationSpecificTlv"] = _OFDPA_python.ofdpaOamLtrEntry_t_organizationSpecificTlv_get
    if _newclass:organizationSpecificTlv = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_organizationSpecificTlv_get, _OFDPA_python.ofdpaOamLtrEntry_t_organizationSpecificTlv_set)
    __swig_setmethods__["senderIdTlv"] = _OFDPA_python.ofdpaOamLtrEntry_t_senderIdTlv_set
    __swig_getmethods__["senderIdTlv"] = _OFDPA_python.ofdpaOamLtrEntry_t_senderIdTlv_get
    if _newclass:senderIdTlv = _swig_property(_OFDPA_python.ofdpaOamLtrEntry_t_senderIdTlv_get, _OFDPA_python.ofdpaOamLtrEntry_t_senderIdTlv_set)
    def __init__(self): 
        """__init__(ofdpaOamLtrEntry_s self) -> ofdpaOamLtrEntry_t"""
        this = _OFDPA_python.new_ofdpaOamLtrEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamLtrEntry_t
    __del__ = lambda self : None;
ofdpaOamLtrEntry_t_swigregister = _OFDPA_python.ofdpaOamLtrEntry_t_swigregister
ofdpaOamLtrEntry_t_swigregister(ofdpaOamLtrEntry_t)

class ofdpaOamProLmConfig_t(_object):
    """Proxy of C ofdpaOamProLmConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamProLmConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamProLmConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["toolType"] = _OFDPA_python.ofdpaOamProLmConfig_t_toolType_set
    __swig_getmethods__["toolType"] = _OFDPA_python.ofdpaOamProLmConfig_t_toolType_get
    if _newclass:toolType = _swig_property(_OFDPA_python.ofdpaOamProLmConfig_t_toolType_get, _OFDPA_python.ofdpaOamProLmConfig_t_toolType_set)
    __swig_setmethods__["proLmDestMpId"] = _OFDPA_python.ofdpaOamProLmConfig_t_proLmDestMpId_set
    __swig_getmethods__["proLmDestMpId"] = _OFDPA_python.ofdpaOamProLmConfig_t_proLmDestMpId_get
    if _newclass:proLmDestMpId = _swig_property(_OFDPA_python.ofdpaOamProLmConfig_t_proLmDestMpId_get, _OFDPA_python.ofdpaOamProLmConfig_t_proLmDestMpId_set)
    __swig_setmethods__["period"] = _OFDPA_python.ofdpaOamProLmConfig_t_period_set
    __swig_getmethods__["period"] = _OFDPA_python.ofdpaOamProLmConfig_t_period_get
    if _newclass:period = _swig_property(_OFDPA_python.ofdpaOamProLmConfig_t_period_get, _OFDPA_python.ofdpaOamProLmConfig_t_period_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaOamProLmConfig_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaOamProLmConfig_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaOamProLmConfig_t_trafficClass_get, _OFDPA_python.ofdpaOamProLmConfig_t_trafficClass_set)
    __swig_setmethods__["testId"] = _OFDPA_python.ofdpaOamProLmConfig_t_testId_set
    __swig_getmethods__["testId"] = _OFDPA_python.ofdpaOamProLmConfig_t_testId_get
    if _newclass:testId = _swig_property(_OFDPA_python.ofdpaOamProLmConfig_t_testId_get, _OFDPA_python.ofdpaOamProLmConfig_t_testId_set)
    def __init__(self): 
        """__init__(ofdpaOamProLmConfig_s self) -> ofdpaOamProLmConfig_t"""
        this = _OFDPA_python.new_ofdpaOamProLmConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamProLmConfig_t
    __del__ = lambda self : None;
ofdpaOamProLmConfig_t_swigregister = _OFDPA_python.ofdpaOamProLmConfig_t_swigregister
ofdpaOamProLmConfig_t_swigregister(ofdpaOamProLmConfig_t)

class ofdpaOamProLmStatus_t(_object):
    """Proxy of C ofdpaOamProLmStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamProLmStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamProLmStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["proLmState"] = _OFDPA_python.ofdpaOamProLmStatus_t_proLmState_set
    __swig_getmethods__["proLmState"] = _OFDPA_python.ofdpaOamProLmStatus_t_proLmState_get
    if _newclass:proLmState = _swig_property(_OFDPA_python.ofdpaOamProLmStatus_t_proLmState_get, _OFDPA_python.ofdpaOamProLmStatus_t_proLmState_set)
    def __init__(self): 
        """__init__(ofdpaOamProLmStatus_s self) -> ofdpaOamProLmStatus_t"""
        this = _OFDPA_python.new_ofdpaOamProLmStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamProLmStatus_t
    __del__ = lambda self : None;
ofdpaOamProLmStatus_t_swigregister = _OFDPA_python.ofdpaOamProLmStatus_t_swigregister
ofdpaOamProLmStatus_t_swigregister(ofdpaOamProLmStatus_t)

class ofdpaOamOdLmConfig_t(_object):
    """Proxy of C ofdpaOamOdLmConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamOdLmConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamOdLmConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["toolType"] = _OFDPA_python.ofdpaOamOdLmConfig_t_toolType_set
    __swig_getmethods__["toolType"] = _OFDPA_python.ofdpaOamOdLmConfig_t_toolType_get
    if _newclass:toolType = _swig_property(_OFDPA_python.ofdpaOamOdLmConfig_t_toolType_get, _OFDPA_python.ofdpaOamOdLmConfig_t_toolType_set)
    __swig_setmethods__["odLmDestMpId"] = _OFDPA_python.ofdpaOamOdLmConfig_t_odLmDestMpId_set
    __swig_getmethods__["odLmDestMpId"] = _OFDPA_python.ofdpaOamOdLmConfig_t_odLmDestMpId_get
    if _newclass:odLmDestMpId = _swig_property(_OFDPA_python.ofdpaOamOdLmConfig_t_odLmDestMpId_get, _OFDPA_python.ofdpaOamOdLmConfig_t_odLmDestMpId_set)
    __swig_setmethods__["period"] = _OFDPA_python.ofdpaOamOdLmConfig_t_period_set
    __swig_getmethods__["period"] = _OFDPA_python.ofdpaOamOdLmConfig_t_period_get
    if _newclass:period = _swig_property(_OFDPA_python.ofdpaOamOdLmConfig_t_period_get, _OFDPA_python.ofdpaOamOdLmConfig_t_period_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaOamOdLmConfig_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaOamOdLmConfig_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaOamOdLmConfig_t_trafficClass_get, _OFDPA_python.ofdpaOamOdLmConfig_t_trafficClass_set)
    __swig_setmethods__["role"] = _OFDPA_python.ofdpaOamOdLmConfig_t_role_set
    __swig_getmethods__["role"] = _OFDPA_python.ofdpaOamOdLmConfig_t_role_get
    if _newclass:role = _swig_property(_OFDPA_python.ofdpaOamOdLmConfig_t_role_get, _OFDPA_python.ofdpaOamOdLmConfig_t_role_set)
    __swig_setmethods__["testId"] = _OFDPA_python.ofdpaOamOdLmConfig_t_testId_set
    __swig_getmethods__["testId"] = _OFDPA_python.ofdpaOamOdLmConfig_t_testId_get
    if _newclass:testId = _swig_property(_OFDPA_python.ofdpaOamOdLmConfig_t_testId_get, _OFDPA_python.ofdpaOamOdLmConfig_t_testId_set)
    def __init__(self): 
        """__init__(ofdpaOamOdLmConfig_s self) -> ofdpaOamOdLmConfig_t"""
        this = _OFDPA_python.new_ofdpaOamOdLmConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamOdLmConfig_t
    __del__ = lambda self : None;
ofdpaOamOdLmConfig_t_swigregister = _OFDPA_python.ofdpaOamOdLmConfig_t_swigregister
ofdpaOamOdLmConfig_t_swigregister(ofdpaOamOdLmConfig_t)

class ofdpaOamOdLmStatus_t(_object):
    """Proxy of C ofdpaOamOdLmStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamOdLmStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamOdLmStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["odLmState"] = _OFDPA_python.ofdpaOamOdLmStatus_t_odLmState_set
    __swig_getmethods__["odLmState"] = _OFDPA_python.ofdpaOamOdLmStatus_t_odLmState_get
    if _newclass:odLmState = _swig_property(_OFDPA_python.ofdpaOamOdLmStatus_t_odLmState_get, _OFDPA_python.ofdpaOamOdLmStatus_t_odLmState_set)
    def __init__(self): 
        """__init__(ofdpaOamOdLmStatus_s self) -> ofdpaOamOdLmStatus_t"""
        this = _OFDPA_python.new_ofdpaOamOdLmStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamOdLmStatus_t
    __del__ = lambda self : None;
ofdpaOamOdLmStatus_t_swigregister = _OFDPA_python.ofdpaOamOdLmStatus_t_swigregister
ofdpaOamOdLmStatus_t_swigregister(ofdpaOamOdLmStatus_t)

class ofdpaOamProDmConfig_t(_object):
    """Proxy of C ofdpaOamProDmConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamProDmConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamProDmConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["proDmDestMpId"] = _OFDPA_python.ofdpaOamProDmConfig_t_proDmDestMpId_set
    __swig_getmethods__["proDmDestMpId"] = _OFDPA_python.ofdpaOamProDmConfig_t_proDmDestMpId_get
    if _newclass:proDmDestMpId = _swig_property(_OFDPA_python.ofdpaOamProDmConfig_t_proDmDestMpId_get, _OFDPA_python.ofdpaOamProDmConfig_t_proDmDestMpId_set)
    __swig_setmethods__["period"] = _OFDPA_python.ofdpaOamProDmConfig_t_period_set
    __swig_getmethods__["period"] = _OFDPA_python.ofdpaOamProDmConfig_t_period_get
    if _newclass:period = _swig_property(_OFDPA_python.ofdpaOamProDmConfig_t_period_get, _OFDPA_python.ofdpaOamProDmConfig_t_period_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaOamProDmConfig_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaOamProDmConfig_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaOamProDmConfig_t_trafficClass_get, _OFDPA_python.ofdpaOamProDmConfig_t_trafficClass_set)
    __swig_setmethods__["frameLen"] = _OFDPA_python.ofdpaOamProDmConfig_t_frameLen_set
    __swig_getmethods__["frameLen"] = _OFDPA_python.ofdpaOamProDmConfig_t_frameLen_get
    if _newclass:frameLen = _swig_property(_OFDPA_python.ofdpaOamProDmConfig_t_frameLen_get, _OFDPA_python.ofdpaOamProDmConfig_t_frameLen_set)
    def __init__(self): 
        """__init__(ofdpaOamProDmConfig_s self) -> ofdpaOamProDmConfig_t"""
        this = _OFDPA_python.new_ofdpaOamProDmConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamProDmConfig_t
    __del__ = lambda self : None;
ofdpaOamProDmConfig_t_swigregister = _OFDPA_python.ofdpaOamProDmConfig_t_swigregister
ofdpaOamProDmConfig_t_swigregister(ofdpaOamProDmConfig_t)

class ofdpaOamProDmStatus_t(_object):
    """Proxy of C ofdpaOamProDmStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamProDmStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamProDmStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["proDmState"] = _OFDPA_python.ofdpaOamProDmStatus_t_proDmState_set
    __swig_getmethods__["proDmState"] = _OFDPA_python.ofdpaOamProDmStatus_t_proDmState_get
    if _newclass:proDmState = _swig_property(_OFDPA_python.ofdpaOamProDmStatus_t_proDmState_get, _OFDPA_python.ofdpaOamProDmStatus_t_proDmState_set)
    def __init__(self): 
        """__init__(ofdpaOamProDmStatus_s self) -> ofdpaOamProDmStatus_t"""
        this = _OFDPA_python.new_ofdpaOamProDmStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamProDmStatus_t
    __del__ = lambda self : None;
ofdpaOamProDmStatus_t_swigregister = _OFDPA_python.ofdpaOamProDmStatus_t_swigregister
ofdpaOamProDmStatus_t_swigregister(ofdpaOamProDmStatus_t)

class ofdpaOamOdDmConfig_t(_object):
    """Proxy of C ofdpaOamOdDmConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamOdDmConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamOdDmConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["odDmDestMpId"] = _OFDPA_python.ofdpaOamOdDmConfig_t_odDmDestMpId_set
    __swig_getmethods__["odDmDestMpId"] = _OFDPA_python.ofdpaOamOdDmConfig_t_odDmDestMpId_get
    if _newclass:odDmDestMpId = _swig_property(_OFDPA_python.ofdpaOamOdDmConfig_t_odDmDestMpId_get, _OFDPA_python.ofdpaOamOdDmConfig_t_odDmDestMpId_set)
    __swig_setmethods__["period"] = _OFDPA_python.ofdpaOamOdDmConfig_t_period_set
    __swig_getmethods__["period"] = _OFDPA_python.ofdpaOamOdDmConfig_t_period_get
    if _newclass:period = _swig_property(_OFDPA_python.ofdpaOamOdDmConfig_t_period_get, _OFDPA_python.ofdpaOamOdDmConfig_t_period_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaOamOdDmConfig_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaOamOdDmConfig_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaOamOdDmConfig_t_trafficClass_get, _OFDPA_python.ofdpaOamOdDmConfig_t_trafficClass_set)
    __swig_setmethods__["frameLen"] = _OFDPA_python.ofdpaOamOdDmConfig_t_frameLen_set
    __swig_getmethods__["frameLen"] = _OFDPA_python.ofdpaOamOdDmConfig_t_frameLen_get
    if _newclass:frameLen = _swig_property(_OFDPA_python.ofdpaOamOdDmConfig_t_frameLen_get, _OFDPA_python.ofdpaOamOdDmConfig_t_frameLen_set)
    __swig_setmethods__["role"] = _OFDPA_python.ofdpaOamOdDmConfig_t_role_set
    __swig_getmethods__["role"] = _OFDPA_python.ofdpaOamOdDmConfig_t_role_get
    if _newclass:role = _swig_property(_OFDPA_python.ofdpaOamOdDmConfig_t_role_get, _OFDPA_python.ofdpaOamOdDmConfig_t_role_set)
    def __init__(self): 
        """__init__(ofdpaOamOdDmConfig_s self) -> ofdpaOamOdDmConfig_t"""
        this = _OFDPA_python.new_ofdpaOamOdDmConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamOdDmConfig_t
    __del__ = lambda self : None;
ofdpaOamOdDmConfig_t_swigregister = _OFDPA_python.ofdpaOamOdDmConfig_t_swigregister
ofdpaOamOdDmConfig_t_swigregister(ofdpaOamOdDmConfig_t)

class ofdpaOamOdDmStatus_t(_object):
    """Proxy of C ofdpaOamOdDmStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamOdDmStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamOdDmStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["odDmState"] = _OFDPA_python.ofdpaOamOdDmStatus_t_odDmState_set
    __swig_getmethods__["odDmState"] = _OFDPA_python.ofdpaOamOdDmStatus_t_odDmState_get
    if _newclass:odDmState = _swig_property(_OFDPA_python.ofdpaOamOdDmStatus_t_odDmState_get, _OFDPA_python.ofdpaOamOdDmStatus_t_odDmState_set)
    def __init__(self): 
        """__init__(ofdpaOamOdDmStatus_s self) -> ofdpaOamOdDmStatus_t"""
        this = _OFDPA_python.new_ofdpaOamOdDmStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamOdDmStatus_t
    __del__ = lambda self : None;
ofdpaOamOdDmStatus_t_swigregister = _OFDPA_python.ofdpaOamOdDmStatus_t_swigregister
ofdpaOamOdDmStatus_t_swigregister(ofdpaOamOdDmStatus_t)

OFDPA_OAM_BIN_MODE_15M = _OFDPA_python.OFDPA_OAM_BIN_MODE_15M
OFDPA_OAM_BIN_MODE_24H = _OFDPA_python.OFDPA_OAM_BIN_MODE_24H
OFDPA_OAM_BIN_MODE_MAX = _OFDPA_python.OFDPA_OAM_BIN_MODE_MAX
class ofdpaOamProLmCounterBin_t(_object):
    """Proxy of C ofdpaOamProLmCounterBin_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamProLmCounterBin_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamProLmCounterBin_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mN_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_mN_FLR_set
    __swig_getmethods__["mN_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_mN_FLR_get
    if _newclass:mN_FLR = _swig_property(_OFDPA_python.ofdpaOamProLmCounterBin_t_mN_FLR_get, _OFDPA_python.ofdpaOamProLmCounterBin_t_mN_FLR_set)
    __swig_setmethods__["aN_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_aN_FLR_set
    __swig_getmethods__["aN_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_aN_FLR_get
    if _newclass:aN_FLR = _swig_property(_OFDPA_python.ofdpaOamProLmCounterBin_t_aN_FLR_get, _OFDPA_python.ofdpaOamProLmCounterBin_t_aN_FLR_set)
    __swig_setmethods__["xN_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_xN_FLR_set
    __swig_getmethods__["xN_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_xN_FLR_get
    if _newclass:xN_FLR = _swig_property(_OFDPA_python.ofdpaOamProLmCounterBin_t_xN_FLR_get, _OFDPA_python.ofdpaOamProLmCounterBin_t_xN_FLR_set)
    __swig_setmethods__["mF_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_mF_FLR_set
    __swig_getmethods__["mF_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_mF_FLR_get
    if _newclass:mF_FLR = _swig_property(_OFDPA_python.ofdpaOamProLmCounterBin_t_mF_FLR_get, _OFDPA_python.ofdpaOamProLmCounterBin_t_mF_FLR_set)
    __swig_setmethods__["aF_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_aF_FLR_set
    __swig_getmethods__["aF_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_aF_FLR_get
    if _newclass:aF_FLR = _swig_property(_OFDPA_python.ofdpaOamProLmCounterBin_t_aF_FLR_get, _OFDPA_python.ofdpaOamProLmCounterBin_t_aF_FLR_set)
    __swig_setmethods__["xF_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_xF_FLR_set
    __swig_getmethods__["xF_FLR"] = _OFDPA_python.ofdpaOamProLmCounterBin_t_xF_FLR_get
    if _newclass:xF_FLR = _swig_property(_OFDPA_python.ofdpaOamProLmCounterBin_t_xF_FLR_get, _OFDPA_python.ofdpaOamProLmCounterBin_t_xF_FLR_set)
    def __init__(self): 
        """__init__(ofdpaOamProLmCounterBin_s self) -> ofdpaOamProLmCounterBin_t"""
        this = _OFDPA_python.new_ofdpaOamProLmCounterBin_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamProLmCounterBin_t
    __del__ = lambda self : None;
ofdpaOamProLmCounterBin_t_swigregister = _OFDPA_python.ofdpaOamProLmCounterBin_t_swigregister
ofdpaOamProLmCounterBin_t_swigregister(ofdpaOamProLmCounterBin_t)

class ofdpaOamProLmCounters_t(_object):
    """Proxy of C ofdpaOamProLmCounters_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamProLmCounters_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamProLmCounters_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["bin_15min"] = _OFDPA_python.ofdpaOamProLmCounters_t_bin_15min_set
    __swig_getmethods__["bin_15min"] = _OFDPA_python.ofdpaOamProLmCounters_t_bin_15min_get
    if _newclass:bin_15min = _swig_property(_OFDPA_python.ofdpaOamProLmCounters_t_bin_15min_get, _OFDPA_python.ofdpaOamProLmCounters_t_bin_15min_set)
    __swig_setmethods__["bin_24hr"] = _OFDPA_python.ofdpaOamProLmCounters_t_bin_24hr_set
    __swig_getmethods__["bin_24hr"] = _OFDPA_python.ofdpaOamProLmCounters_t_bin_24hr_get
    if _newclass:bin_24hr = _swig_property(_OFDPA_python.ofdpaOamProLmCounters_t_bin_24hr_get, _OFDPA_python.ofdpaOamProLmCounters_t_bin_24hr_set)
    def __init__(self): 
        """__init__(ofdpaOamProLmCounters_s self) -> ofdpaOamProLmCounters_t"""
        this = _OFDPA_python.new_ofdpaOamProLmCounters_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamProLmCounters_t
    __del__ = lambda self : None;
ofdpaOamProLmCounters_t_swigregister = _OFDPA_python.ofdpaOamProLmCounters_t_swigregister
ofdpaOamProLmCounters_t_swigregister(ofdpaOamProLmCounters_t)

class ofdpaOamOdLmSnapshot_t(_object):
    """Proxy of C ofdpaOamOdLmSnapshot_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamOdLmSnapshot_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamOdLmSnapshot_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tNTFCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tNTFCnt_set
    __swig_getmethods__["tNTFCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tNTFCnt_get
    if _newclass:tNTFCnt = _swig_property(_OFDPA_python.ofdpaOamOdLmSnapshot_t_tNTFCnt_get, _OFDPA_python.ofdpaOamOdLmSnapshot_t_tNTFCnt_set)
    __swig_setmethods__["tNLFCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tNLFCnt_set
    __swig_getmethods__["tNLFCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tNLFCnt_get
    if _newclass:tNLFCnt = _swig_property(_OFDPA_python.ofdpaOamOdLmSnapshot_t_tNLFCnt_get, _OFDPA_python.ofdpaOamOdLmSnapshot_t_tNLFCnt_set)
    __swig_setmethods__["tNFLR"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tNFLR_set
    __swig_getmethods__["tNFLR"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tNFLR_get
    if _newclass:tNFLR = _swig_property(_OFDPA_python.ofdpaOamOdLmSnapshot_t_tNFLR_get, _OFDPA_python.ofdpaOamOdLmSnapshot_t_tNFLR_set)
    __swig_setmethods__["tFTFCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tFTFCnt_set
    __swig_getmethods__["tFTFCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tFTFCnt_get
    if _newclass:tFTFCnt = _swig_property(_OFDPA_python.ofdpaOamOdLmSnapshot_t_tFTFCnt_get, _OFDPA_python.ofdpaOamOdLmSnapshot_t_tFTFCnt_set)
    __swig_setmethods__["tFLFCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tFLFCnt_set
    __swig_getmethods__["tFLFCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tFLFCnt_get
    if _newclass:tFLFCnt = _swig_property(_OFDPA_python.ofdpaOamOdLmSnapshot_t_tFLFCnt_get, _OFDPA_python.ofdpaOamOdLmSnapshot_t_tFLFCnt_set)
    __swig_setmethods__["tFFLR"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tFFLR_set
    __swig_getmethods__["tFFLR"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_tFFLR_get
    if _newclass:tFFLR = _swig_property(_OFDPA_python.ofdpaOamOdLmSnapshot_t_tFFLR_get, _OFDPA_python.ofdpaOamOdLmSnapshot_t_tFFLR_set)
    __swig_setmethods__["sLMCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_sLMCnt_set
    __swig_getmethods__["sLMCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_sLMCnt_get
    if _newclass:sLMCnt = _swig_property(_OFDPA_python.ofdpaOamOdLmSnapshot_t_sLMCnt_get, _OFDPA_python.ofdpaOamOdLmSnapshot_t_sLMCnt_set)
    __swig_setmethods__["uLMCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_uLMCnt_set
    __swig_getmethods__["uLMCnt"] = _OFDPA_python.ofdpaOamOdLmSnapshot_t_uLMCnt_get
    if _newclass:uLMCnt = _swig_property(_OFDPA_python.ofdpaOamOdLmSnapshot_t_uLMCnt_get, _OFDPA_python.ofdpaOamOdLmSnapshot_t_uLMCnt_set)
    def __init__(self): 
        """__init__(ofdpaOamOdLmSnapshot_s self) -> ofdpaOamOdLmSnapshot_t"""
        this = _OFDPA_python.new_ofdpaOamOdLmSnapshot_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamOdLmSnapshot_t
    __del__ = lambda self : None;
ofdpaOamOdLmSnapshot_t_swigregister = _OFDPA_python.ofdpaOamOdLmSnapshot_t_swigregister
ofdpaOamOdLmSnapshot_t_swigregister(ofdpaOamOdLmSnapshot_t)

class ofdpaOamProDmCounterBin_t(_object):
    """Proxy of C ofdpaOamProDmCounterBin_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamProDmCounterBin_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamProDmCounterBin_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mB_FD"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_mB_FD_set
    __swig_getmethods__["mB_FD"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_mB_FD_get
    if _newclass:mB_FD = _swig_property(_OFDPA_python.ofdpaOamProDmCounterBin_t_mB_FD_get, _OFDPA_python.ofdpaOamProDmCounterBin_t_mB_FD_set)
    __swig_setmethods__["aB_FD"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_aB_FD_set
    __swig_getmethods__["aB_FD"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_aB_FD_get
    if _newclass:aB_FD = _swig_property(_OFDPA_python.ofdpaOamProDmCounterBin_t_aB_FD_get, _OFDPA_python.ofdpaOamProDmCounterBin_t_aB_FD_set)
    __swig_setmethods__["xB_FD"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_xB_FD_set
    __swig_getmethods__["xB_FD"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_xB_FD_get
    if _newclass:xB_FD = _swig_property(_OFDPA_python.ofdpaOamProDmCounterBin_t_xB_FD_get, _OFDPA_python.ofdpaOamProDmCounterBin_t_xB_FD_set)
    __swig_setmethods__["mN_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_mN_FDV_set
    __swig_getmethods__["mN_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_mN_FDV_get
    if _newclass:mN_FDV = _swig_property(_OFDPA_python.ofdpaOamProDmCounterBin_t_mN_FDV_get, _OFDPA_python.ofdpaOamProDmCounterBin_t_mN_FDV_set)
    __swig_setmethods__["aN_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_aN_FDV_set
    __swig_getmethods__["aN_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_aN_FDV_get
    if _newclass:aN_FDV = _swig_property(_OFDPA_python.ofdpaOamProDmCounterBin_t_aN_FDV_get, _OFDPA_python.ofdpaOamProDmCounterBin_t_aN_FDV_set)
    __swig_setmethods__["xN_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_xN_FDV_set
    __swig_getmethods__["xN_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_xN_FDV_get
    if _newclass:xN_FDV = _swig_property(_OFDPA_python.ofdpaOamProDmCounterBin_t_xN_FDV_get, _OFDPA_python.ofdpaOamProDmCounterBin_t_xN_FDV_set)
    __swig_setmethods__["mF_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_mF_FDV_set
    __swig_getmethods__["mF_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_mF_FDV_get
    if _newclass:mF_FDV = _swig_property(_OFDPA_python.ofdpaOamProDmCounterBin_t_mF_FDV_get, _OFDPA_python.ofdpaOamProDmCounterBin_t_mF_FDV_set)
    __swig_setmethods__["aF_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_aF_FDV_set
    __swig_getmethods__["aF_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_aF_FDV_get
    if _newclass:aF_FDV = _swig_property(_OFDPA_python.ofdpaOamProDmCounterBin_t_aF_FDV_get, _OFDPA_python.ofdpaOamProDmCounterBin_t_aF_FDV_set)
    __swig_setmethods__["xF_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_xF_FDV_set
    __swig_getmethods__["xF_FDV"] = _OFDPA_python.ofdpaOamProDmCounterBin_t_xF_FDV_get
    if _newclass:xF_FDV = _swig_property(_OFDPA_python.ofdpaOamProDmCounterBin_t_xF_FDV_get, _OFDPA_python.ofdpaOamProDmCounterBin_t_xF_FDV_set)
    def __init__(self): 
        """__init__(ofdpaOamProDmCounterBin_s self) -> ofdpaOamProDmCounterBin_t"""
        this = _OFDPA_python.new_ofdpaOamProDmCounterBin_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamProDmCounterBin_t
    __del__ = lambda self : None;
ofdpaOamProDmCounterBin_t_swigregister = _OFDPA_python.ofdpaOamProDmCounterBin_t_swigregister
ofdpaOamProDmCounterBin_t_swigregister(ofdpaOamProDmCounterBin_t)

class ofdpaOamProDmCounters_t(_object):
    """Proxy of C ofdpaOamProDmCounters_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamProDmCounters_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamProDmCounters_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["bin_15min"] = _OFDPA_python.ofdpaOamProDmCounters_t_bin_15min_set
    __swig_getmethods__["bin_15min"] = _OFDPA_python.ofdpaOamProDmCounters_t_bin_15min_get
    if _newclass:bin_15min = _swig_property(_OFDPA_python.ofdpaOamProDmCounters_t_bin_15min_get, _OFDPA_python.ofdpaOamProDmCounters_t_bin_15min_set)
    __swig_setmethods__["bin_24hr"] = _OFDPA_python.ofdpaOamProDmCounters_t_bin_24hr_set
    __swig_getmethods__["bin_24hr"] = _OFDPA_python.ofdpaOamProDmCounters_t_bin_24hr_get
    if _newclass:bin_24hr = _swig_property(_OFDPA_python.ofdpaOamProDmCounters_t_bin_24hr_get, _OFDPA_python.ofdpaOamProDmCounters_t_bin_24hr_set)
    def __init__(self): 
        """__init__(ofdpaOamProDmCounters_s self) -> ofdpaOamProDmCounters_t"""
        this = _OFDPA_python.new_ofdpaOamProDmCounters_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamProDmCounters_t
    __del__ = lambda self : None;
ofdpaOamProDmCounters_t_swigregister = _OFDPA_python.ofdpaOamProDmCounters_t_swigregister
ofdpaOamProDmCounters_t_swigregister(ofdpaOamProDmCounters_t)

class ofdpaOamOdDmSnapshot_t(_object):
    """Proxy of C ofdpaOamOdDmSnapshot_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamOdDmSnapshot_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamOdDmSnapshot_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["tN_FD"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_tN_FD_set
    __swig_getmethods__["tN_FD"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_tN_FD_get
    if _newclass:tN_FD = _swig_property(_OFDPA_python.ofdpaOamOdDmSnapshot_t_tN_FD_get, _OFDPA_python.ofdpaOamOdDmSnapshot_t_tN_FD_set)
    __swig_setmethods__["tF_FD"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_tF_FD_set
    __swig_getmethods__["tF_FD"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_tF_FD_get
    if _newclass:tF_FD = _swig_property(_OFDPA_python.ofdpaOamOdDmSnapshot_t_tF_FD_get, _OFDPA_python.ofdpaOamOdDmSnapshot_t_tF_FD_set)
    __swig_setmethods__["tB_FD"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_tB_FD_set
    __swig_getmethods__["tB_FD"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_tB_FD_get
    if _newclass:tB_FD = _swig_property(_OFDPA_python.ofdpaOamOdDmSnapshot_t_tB_FD_get, _OFDPA_python.ofdpaOamOdDmSnapshot_t_tB_FD_set)
    __swig_setmethods__["elapsedTime"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_elapsedTime_set
    __swig_getmethods__["elapsedTime"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_elapsedTime_get
    if _newclass:elapsedTime = _swig_property(_OFDPA_python.ofdpaOamOdDmSnapshot_t_elapsedTime_get, _OFDPA_python.ofdpaOamOdDmSnapshot_t_elapsedTime_set)
    __swig_setmethods__["sFDMCnt"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_sFDMCnt_set
    __swig_getmethods__["sFDMCnt"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_sFDMCnt_get
    if _newclass:sFDMCnt = _swig_property(_OFDPA_python.ofdpaOamOdDmSnapshot_t_sFDMCnt_get, _OFDPA_python.ofdpaOamOdDmSnapshot_t_sFDMCnt_set)
    __swig_setmethods__["uFDMCnt"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_uFDMCnt_set
    __swig_getmethods__["uFDMCnt"] = _OFDPA_python.ofdpaOamOdDmSnapshot_t_uFDMCnt_get
    if _newclass:uFDMCnt = _swig_property(_OFDPA_python.ofdpaOamOdDmSnapshot_t_uFDMCnt_get, _OFDPA_python.ofdpaOamOdDmSnapshot_t_uFDMCnt_set)
    def __init__(self): 
        """__init__(ofdpaOamOdDmSnapshot_s self) -> ofdpaOamOdDmSnapshot_t"""
        this = _OFDPA_python.new_ofdpaOamOdDmSnapshot_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamOdDmSnapshot_t
    __del__ = lambda self : None;
ofdpaOamOdDmSnapshot_t_swigregister = _OFDPA_python.ofdpaOamOdDmSnapshot_t_swigregister
ofdpaOamOdDmSnapshot_t_swigregister(ofdpaOamOdDmSnapshot_t)

OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_CLEAR = _OFDPA_python.OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_CLEAR
OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_MANUAL_LOCK = _OFDPA_python.OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_MANUAL_LOCK
OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_FORCE_SWITCH = _OFDPA_python.OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_FORCE_SWITCH
OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_MANUAL_SWITCH_P = _OFDPA_python.OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_MANUAL_SWITCH_P
OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_MANUAL_SWITCH = _OFDPA_python.OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_MANUAL_SWITCH
OFDPA_MLP_ARCH_1_TO_1 = _OFDPA_python.OFDPA_MLP_ARCH_1_TO_1
OFDPA_MLP_ARCH_1_PLUS_1 = _OFDPA_python.OFDPA_MLP_ARCH_1_PLUS_1
class ofdpaOamMLPGroupConfig_t(_object):
    """Proxy of C ofdpaOamMLPGroupConfig_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamMLPGroupConfig_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamMLPGroupConfig_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["mlpArchitecture"] = _OFDPA_python.ofdpaOamMLPGroupConfig_t_mlpArchitecture_set
    __swig_getmethods__["mlpArchitecture"] = _OFDPA_python.ofdpaOamMLPGroupConfig_t_mlpArchitecture_get
    if _newclass:mlpArchitecture = _swig_property(_OFDPA_python.ofdpaOamMLPGroupConfig_t_mlpArchitecture_get, _OFDPA_python.ofdpaOamMLPGroupConfig_t_mlpArchitecture_set)
    __swig_setmethods__["holdOffTime"] = _OFDPA_python.ofdpaOamMLPGroupConfig_t_holdOffTime_set
    __swig_getmethods__["holdOffTime"] = _OFDPA_python.ofdpaOamMLPGroupConfig_t_holdOffTime_get
    if _newclass:holdOffTime = _swig_property(_OFDPA_python.ofdpaOamMLPGroupConfig_t_holdOffTime_get, _OFDPA_python.ofdpaOamMLPGroupConfig_t_holdOffTime_set)
    __swig_setmethods__["wtrTime"] = _OFDPA_python.ofdpaOamMLPGroupConfig_t_wtrTime_set
    __swig_getmethods__["wtrTime"] = _OFDPA_python.ofdpaOamMLPGroupConfig_t_wtrTime_get
    if _newclass:wtrTime = _swig_property(_OFDPA_python.ofdpaOamMLPGroupConfig_t_wtrTime_get, _OFDPA_python.ofdpaOamMLPGroupConfig_t_wtrTime_set)
    __swig_setmethods__["revertiveMode"] = _OFDPA_python.ofdpaOamMLPGroupConfig_t_revertiveMode_set
    __swig_getmethods__["revertiveMode"] = _OFDPA_python.ofdpaOamMLPGroupConfig_t_revertiveMode_get
    if _newclass:revertiveMode = _swig_property(_OFDPA_python.ofdpaOamMLPGroupConfig_t_revertiveMode_get, _OFDPA_python.ofdpaOamMLPGroupConfig_t_revertiveMode_set)
    def __init__(self): 
        """__init__(ofdpaOamMLPGroupConfig_s self) -> ofdpaOamMLPGroupConfig_t"""
        this = _OFDPA_python.new_ofdpaOamMLPGroupConfig_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamMLPGroupConfig_t
    __del__ = lambda self : None;
ofdpaOamMLPGroupConfig_t_swigregister = _OFDPA_python.ofdpaOamMLPGroupConfig_t_swigregister
ofdpaOamMLPGroupConfig_t_swigregister(ofdpaOamMLPGroupConfig_t)

class ofdpaOamMLPGroupStatus_t(_object):
    """Proxy of C ofdpaOamMLPGroupStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamMLPGroupStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamMLPGroupStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lastLReq"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_lastLReq_set
    __swig_getmethods__["lastLReq"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_lastLReq_get
    if _newclass:lastLReq = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_lastLReq_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_lastLReq_set)
    __swig_setmethods__["lastRReq"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_lastRReq_set
    __swig_getmethods__["lastRReq"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_lastRReq_get
    if _newclass:lastRReq = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_lastRReq_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_lastRReq_set)
    __swig_setmethods__["lastSReq"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_lastSReq_set
    __swig_getmethods__["lastSReq"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_lastSReq_get
    if _newclass:lastSReq = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_lastSReq_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_lastSReq_set)
    __swig_setmethods__["sfwState"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_sfwState_set
    __swig_getmethods__["sfwState"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_sfwState_get
    if _newclass:sfwState = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_sfwState_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_sfwState_set)
    __swig_setmethods__["sfpState"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_sfpState_set
    __swig_getmethods__["sfpState"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_sfpState_get
    if _newclass:sfpState = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_sfpState_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_sfpState_set)
    __swig_setmethods__["sdwState"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_sdwState_set
    __swig_getmethods__["sdwState"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_sdwState_get
    if _newclass:sdwState = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_sdwState_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_sdwState_set)
    __swig_setmethods__["sdpState"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_sdpState_set
    __swig_getmethods__["sdpState"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_sdpState_get
    if _newclass:sdpState = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_sdpState_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_sdpState_set)
    __swig_setmethods__["workingStatus"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_workingStatus_set
    __swig_getmethods__["workingStatus"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_workingStatus_get
    if _newclass:workingStatus = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_workingStatus_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_workingStatus_set)
    __swig_setmethods__["standbyStatus"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_standbyStatus_set
    __swig_getmethods__["standbyStatus"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_standbyStatus_get
    if _newclass:standbyStatus = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_standbyStatus_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_standbyStatus_set)
    __swig_setmethods__["holdOffBlock"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_holdOffBlock_set
    __swig_getmethods__["holdOffBlock"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_holdOffBlock_get
    if _newclass:holdOffBlock = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_holdOffBlock_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_holdOffBlock_set)
    __swig_setmethods__["dfop_cm"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_cm_set
    __swig_getmethods__["dfop_cm"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_cm_get
    if _newclass:dfop_cm = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_cm_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_cm_set)
    __swig_setmethods__["dfop_pm"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_pm_set
    __swig_getmethods__["dfop_pm"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_pm_get
    if _newclass:dfop_pm = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_pm_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_pm_set)
    __swig_setmethods__["dfop_nr"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_nr_set
    __swig_getmethods__["dfop_nr"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_nr_get
    if _newclass:dfop_nr = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_nr_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_nr_set)
    __swig_setmethods__["dfop_to"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_to_set
    __swig_getmethods__["dfop_to"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_to_get
    if _newclass:dfop_to = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_to_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_dfop_to_set)
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaOamMLPGroupStatus_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaOamMLPGroupStatus_t_refCount_get, _OFDPA_python.ofdpaOamMLPGroupStatus_t_refCount_set)
    def __init__(self): 
        """__init__(ofdpaOamMLPGroupStatus_s self) -> ofdpaOamMLPGroupStatus_t"""
        this = _OFDPA_python.new_ofdpaOamMLPGroupStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamMLPGroupStatus_t
    __del__ = lambda self : None;
ofdpaOamMLPGroupStatus_t_swigregister = _OFDPA_python.ofdpaOamMLPGroupStatus_t_swigregister
ofdpaOamMLPGroupStatus_t_swigregister(ofdpaOamMLPGroupStatus_t)

OFDPA_OAM_EVENT_ON_DEMAND_LM_SESSION_COMPLETED = _OFDPA_python.OFDPA_OAM_EVENT_ON_DEMAND_LM_SESSION_COMPLETED
OFDPA_OAM_EVENT_ON_DEMAND_DM_SESSION_COMPLETED = _OFDPA_python.OFDPA_OAM_EVENT_ON_DEMAND_DM_SESSION_COMPLETED
class ofdpaOamEvent_t(_object):
    """Proxy of C ofdpaOamEvent_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamEvent_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamEvent_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["eventMask"] = _OFDPA_python.ofdpaOamEvent_t_eventMask_set
    __swig_getmethods__["eventMask"] = _OFDPA_python.ofdpaOamEvent_t_eventMask_get
    if _newclass:eventMask = _swig_property(_OFDPA_python.ofdpaOamEvent_t_eventMask_get, _OFDPA_python.ofdpaOamEvent_t_eventMask_set)
    __swig_setmethods__["megIndex"] = _OFDPA_python.ofdpaOamEvent_t_megIndex_set
    __swig_getmethods__["megIndex"] = _OFDPA_python.ofdpaOamEvent_t_megIndex_get
    if _newclass:megIndex = _swig_property(_OFDPA_python.ofdpaOamEvent_t_megIndex_get, _OFDPA_python.ofdpaOamEvent_t_megIndex_set)
    __swig_setmethods__["mepId"] = _OFDPA_python.ofdpaOamEvent_t_mepId_set
    __swig_getmethods__["mepId"] = _OFDPA_python.ofdpaOamEvent_t_mepId_get
    if _newclass:mepId = _swig_property(_OFDPA_python.ofdpaOamEvent_t_mepId_get, _OFDPA_python.ofdpaOamEvent_t_mepId_set)
    def __init__(self): 
        """__init__(ofdpaOamEvent_s self) -> ofdpaOamEvent_t"""
        this = _OFDPA_python.new_ofdpaOamEvent_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamEvent_t
    __del__ = lambda self : None;
ofdpaOamEvent_t_swigregister = _OFDPA_python.ofdpaOamEvent_t_swigregister
ofdpaOamEvent_t_swigregister(ofdpaOamEvent_t)

class ofdpaMplsQosEntry_t(_object):
    """Proxy of C ofdpaMplsQosEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaMplsQosEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaMplsQosEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["qosIndex"] = _OFDPA_python.ofdpaMplsQosEntry_t_qosIndex_set
    __swig_getmethods__["qosIndex"] = _OFDPA_python.ofdpaMplsQosEntry_t_qosIndex_get
    if _newclass:qosIndex = _swig_property(_OFDPA_python.ofdpaMplsQosEntry_t_qosIndex_get, _OFDPA_python.ofdpaMplsQosEntry_t_qosIndex_set)
    __swig_setmethods__["mpls_tc"] = _OFDPA_python.ofdpaMplsQosEntry_t_mpls_tc_set
    __swig_getmethods__["mpls_tc"] = _OFDPA_python.ofdpaMplsQosEntry_t_mpls_tc_get
    if _newclass:mpls_tc = _swig_property(_OFDPA_python.ofdpaMplsQosEntry_t_mpls_tc_get, _OFDPA_python.ofdpaMplsQosEntry_t_mpls_tc_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaMplsQosEntry_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaMplsQosEntry_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaMplsQosEntry_t_trafficClass_get, _OFDPA_python.ofdpaMplsQosEntry_t_trafficClass_set)
    __swig_setmethods__["color"] = _OFDPA_python.ofdpaMplsQosEntry_t_color_set
    __swig_getmethods__["color"] = _OFDPA_python.ofdpaMplsQosEntry_t_color_get
    if _newclass:color = _swig_property(_OFDPA_python.ofdpaMplsQosEntry_t_color_get, _OFDPA_python.ofdpaMplsQosEntry_t_color_set)
    def __init__(self): 
        """__init__(ofdpaMplsQosEntry_s self) -> ofdpaMplsQosEntry_t"""
        this = _OFDPA_python.new_ofdpaMplsQosEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaMplsQosEntry_t
    __del__ = lambda self : None;
ofdpaMplsQosEntry_t_swigregister = _OFDPA_python.ofdpaMplsQosEntry_t_swigregister
ofdpaMplsQosEntry_t_swigregister(ofdpaMplsQosEntry_t)

OFDPA_DROP_TABLE_STATUS_LOCK = _OFDPA_python.OFDPA_DROP_TABLE_STATUS_LOCK
class ofdpaDropStatusEntry_t(_object):
    """Proxy of C ofdpaDropStatusEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaDropStatusEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaDropStatusEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaDropStatusEntry_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaDropStatusEntry_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaDropStatusEntry_t_lmepId_get, _OFDPA_python.ofdpaDropStatusEntry_t_lmepId_set)
    __swig_setmethods__["type"] = _OFDPA_python.ofdpaDropStatusEntry_t_type_set
    __swig_getmethods__["type"] = _OFDPA_python.ofdpaDropStatusEntry_t_type_get
    if _newclass:type = _swig_property(_OFDPA_python.ofdpaDropStatusEntry_t_type_get, _OFDPA_python.ofdpaDropStatusEntry_t_type_set)
    __swig_setmethods__["dropAction"] = _OFDPA_python.ofdpaDropStatusEntry_t_dropAction_set
    __swig_getmethods__["dropAction"] = _OFDPA_python.ofdpaDropStatusEntry_t_dropAction_get
    if _newclass:dropAction = _swig_property(_OFDPA_python.ofdpaDropStatusEntry_t_dropAction_get, _OFDPA_python.ofdpaDropStatusEntry_t_dropAction_set)
    def __init__(self): 
        """__init__(ofdpaDropStatusEntry_s self) -> ofdpaDropStatusEntry_t"""
        this = _OFDPA_python.new_ofdpaDropStatusEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaDropStatusEntry_t
    __del__ = lambda self : None;
ofdpaDropStatusEntry_t_swigregister = _OFDPA_python.ofdpaDropStatusEntry_t_swigregister
ofdpaDropStatusEntry_t_swigregister(ofdpaDropStatusEntry_t)

class ofdpaOamDataCounterIndex_t(_object):
    """Proxy of C ofdpaOamDataCounterIndex_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamDataCounterIndex_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamDataCounterIndex_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["lmepId"] = _OFDPA_python.ofdpaOamDataCounterIndex_t_lmepId_set
    __swig_getmethods__["lmepId"] = _OFDPA_python.ofdpaOamDataCounterIndex_t_lmepId_get
    if _newclass:lmepId = _swig_property(_OFDPA_python.ofdpaOamDataCounterIndex_t_lmepId_get, _OFDPA_python.ofdpaOamDataCounterIndex_t_lmepId_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaOamDataCounterIndex_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaOamDataCounterIndex_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaOamDataCounterIndex_t_trafficClass_get, _OFDPA_python.ofdpaOamDataCounterIndex_t_trafficClass_set)
    def __init__(self): 
        """__init__(ofdpaOamDataCounterIndex_s self) -> ofdpaOamDataCounterIndex_t"""
        this = _OFDPA_python.new_ofdpaOamDataCounterIndex_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamDataCounterIndex_t
    __del__ = lambda self : None;
ofdpaOamDataCounterIndex_t_swigregister = _OFDPA_python.ofdpaOamDataCounterIndex_t_swigregister
ofdpaOamDataCounterIndex_t_swigregister(ofdpaOamDataCounterIndex_t)

class ofdpaOamDataCounterStatus_t(_object):
    """Proxy of C ofdpaOamDataCounterStatus_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaOamDataCounterStatus_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaOamDataCounterStatus_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["refCount"] = _OFDPA_python.ofdpaOamDataCounterStatus_t_refCount_set
    __swig_getmethods__["refCount"] = _OFDPA_python.ofdpaOamDataCounterStatus_t_refCount_get
    if _newclass:refCount = _swig_property(_OFDPA_python.ofdpaOamDataCounterStatus_t_refCount_get, _OFDPA_python.ofdpaOamDataCounterStatus_t_refCount_set)
    def __init__(self): 
        """__init__(ofdpaOamDataCounterStatus_s self) -> ofdpaOamDataCounterStatus_t"""
        this = _OFDPA_python.new_ofdpaOamDataCounterStatus_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaOamDataCounterStatus_t
    __del__ = lambda self : None;
ofdpaOamDataCounterStatus_t_swigregister = _OFDPA_python.ofdpaOamDataCounterStatus_t_swigregister
ofdpaOamDataCounterStatus_t_swigregister(ofdpaOamDataCounterStatus_t)

class ofdpaRemarkSetActions_t(_object):
    """Proxy of C ofdpaRemarkSetActions_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaRemarkSetActions_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaRemarkSetActions_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["remarkData"] = _OFDPA_python.ofdpaRemarkSetActions_t_remarkData_set
    __swig_getmethods__["remarkData"] = _OFDPA_python.ofdpaRemarkSetActions_t_remarkData_get
    if _newclass:remarkData = _swig_property(_OFDPA_python.ofdpaRemarkSetActions_t_remarkData_get, _OFDPA_python.ofdpaRemarkSetActions_t_remarkData_set)
    __swig_setmethods__["vlanPcp"] = _OFDPA_python.ofdpaRemarkSetActions_t_vlanPcp_set
    __swig_getmethods__["vlanPcp"] = _OFDPA_python.ofdpaRemarkSetActions_t_vlanPcp_get
    if _newclass:vlanPcp = _swig_property(_OFDPA_python.ofdpaRemarkSetActions_t_vlanPcp_get, _OFDPA_python.ofdpaRemarkSetActions_t_vlanPcp_set)
    __swig_setmethods__["vlanDei"] = _OFDPA_python.ofdpaRemarkSetActions_t_vlanDei_set
    __swig_getmethods__["vlanDei"] = _OFDPA_python.ofdpaRemarkSetActions_t_vlanDei_get
    if _newclass:vlanDei = _swig_property(_OFDPA_python.ofdpaRemarkSetActions_t_vlanDei_get, _OFDPA_python.ofdpaRemarkSetActions_t_vlanDei_set)
    def __init__(self): 
        """__init__(ofdpaRemarkSetActions_s self) -> ofdpaRemarkSetActions_t"""
        this = _OFDPA_python.new_ofdpaRemarkSetActions_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaRemarkSetActions_t
    __del__ = lambda self : None;
ofdpaRemarkSetActions_t_swigregister = _OFDPA_python.ofdpaRemarkSetActions_t_swigregister
ofdpaRemarkSetActions_t_swigregister(ofdpaRemarkSetActions_t)

class ofdpaRemarkActionEntry_t(_object):
    """Proxy of C ofdpaRemarkActionEntry_s struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ofdpaRemarkActionEntry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ofdpaRemarkActionEntry_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["actionTableType"] = _OFDPA_python.ofdpaRemarkActionEntry_t_actionTableType_set
    __swig_getmethods__["actionTableType"] = _OFDPA_python.ofdpaRemarkActionEntry_t_actionTableType_get
    if _newclass:actionTableType = _swig_property(_OFDPA_python.ofdpaRemarkActionEntry_t_actionTableType_get, _OFDPA_python.ofdpaRemarkActionEntry_t_actionTableType_set)
    __swig_setmethods__["index"] = _OFDPA_python.ofdpaRemarkActionEntry_t_index_set
    __swig_getmethods__["index"] = _OFDPA_python.ofdpaRemarkActionEntry_t_index_get
    if _newclass:index = _swig_property(_OFDPA_python.ofdpaRemarkActionEntry_t_index_get, _OFDPA_python.ofdpaRemarkActionEntry_t_index_set)
    __swig_setmethods__["trafficClass"] = _OFDPA_python.ofdpaRemarkActionEntry_t_trafficClass_set
    __swig_getmethods__["trafficClass"] = _OFDPA_python.ofdpaRemarkActionEntry_t_trafficClass_get
    if _newclass:trafficClass = _swig_property(_OFDPA_python.ofdpaRemarkActionEntry_t_trafficClass_get, _OFDPA_python.ofdpaRemarkActionEntry_t_trafficClass_set)
    __swig_setmethods__["color"] = _OFDPA_python.ofdpaRemarkActionEntry_t_color_set
    __swig_getmethods__["color"] = _OFDPA_python.ofdpaRemarkActionEntry_t_color_get
    if _newclass:color = _swig_property(_OFDPA_python.ofdpaRemarkActionEntry_t_color_get, _OFDPA_python.ofdpaRemarkActionEntry_t_color_set)
    __swig_setmethods__["actions"] = _OFDPA_python.ofdpaRemarkActionEntry_t_actions_set
    __swig_getmethods__["actions"] = _OFDPA_python.ofdpaRemarkActionEntry_t_actions_get
    if _newclass:actions = _swig_property(_OFDPA_python.ofdpaRemarkActionEntry_t_actions_get, _OFDPA_python.ofdpaRemarkActionEntry_t_actions_set)
    def __init__(self): 
        """__init__(ofdpaRemarkActionEntry_s self) -> ofdpaRemarkActionEntry_t"""
        this = _OFDPA_python.new_ofdpaRemarkActionEntry_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _OFDPA_python.delete_ofdpaRemarkActionEntry_t
    __del__ = lambda self : None;
ofdpaRemarkActionEntry_t_swigregister = _OFDPA_python.ofdpaRemarkActionEntry_t_swigregister
ofdpaRemarkActionEntry_t_swigregister(ofdpaRemarkActionEntry_t)


def new_OFDPA_ERROR_tp():
  """new_OFDPA_ERROR_tp() -> OFDPA_ERROR_t *"""
  return _OFDPA_python.new_OFDPA_ERROR_tp()

def copy_OFDPA_ERROR_tp(*args):
  """copy_OFDPA_ERROR_tp(OFDPA_ERROR_t value) -> OFDPA_ERROR_t *"""
  return _OFDPA_python.copy_OFDPA_ERROR_tp(*args)

def delete_OFDPA_ERROR_tp(*args):
  """delete_OFDPA_ERROR_tp(OFDPA_ERROR_t * obj)"""
  return _OFDPA_python.delete_OFDPA_ERROR_tp(*args)

def OFDPA_ERROR_tp_assign(*args):
  """OFDPA_ERROR_tp_assign(OFDPA_ERROR_t * obj, OFDPA_ERROR_t value)"""
  return _OFDPA_python.OFDPA_ERROR_tp_assign(*args)

def OFDPA_ERROR_tp_value(*args):
  """OFDPA_ERROR_tp_value(OFDPA_ERROR_t * obj) -> OFDPA_ERROR_t"""
  return _OFDPA_python.OFDPA_ERROR_tp_value(*args)

def new_OFDPA_FEATURE_tp():
  """new_OFDPA_FEATURE_tp() -> OFDPA_FEATURE_t *"""
  return _OFDPA_python.new_OFDPA_FEATURE_tp()

def copy_OFDPA_FEATURE_tp(*args):
  """copy_OFDPA_FEATURE_tp(OFDPA_FEATURE_t value) -> OFDPA_FEATURE_t *"""
  return _OFDPA_python.copy_OFDPA_FEATURE_tp(*args)

def delete_OFDPA_FEATURE_tp(*args):
  """delete_OFDPA_FEATURE_tp(OFDPA_FEATURE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_FEATURE_tp(*args)

def OFDPA_FEATURE_tp_assign(*args):
  """OFDPA_FEATURE_tp_assign(OFDPA_FEATURE_t * obj, OFDPA_FEATURE_t value)"""
  return _OFDPA_python.OFDPA_FEATURE_tp_assign(*args)

def OFDPA_FEATURE_tp_value(*args):
  """OFDPA_FEATURE_tp_value(OFDPA_FEATURE_t * obj) -> OFDPA_FEATURE_t"""
  return _OFDPA_python.OFDPA_FEATURE_tp_value(*args)

def new_OFDPA_BOOLp():
  """new_OFDPA_BOOLp() -> OFDPA_BOOL *"""
  return _OFDPA_python.new_OFDPA_BOOLp()

def copy_OFDPA_BOOLp(*args):
  """copy_OFDPA_BOOLp(OFDPA_BOOL value) -> OFDPA_BOOL *"""
  return _OFDPA_python.copy_OFDPA_BOOLp(*args)

def delete_OFDPA_BOOLp(*args):
  """delete_OFDPA_BOOLp(OFDPA_BOOL * obj)"""
  return _OFDPA_python.delete_OFDPA_BOOLp(*args)

def OFDPA_BOOLp_assign(*args):
  """OFDPA_BOOLp_assign(OFDPA_BOOL * obj, OFDPA_BOOL value)"""
  return _OFDPA_python.OFDPA_BOOLp_assign(*args)

def OFDPA_BOOLp_value(*args):
  """OFDPA_BOOLp_value(OFDPA_BOOL * obj) -> OFDPA_BOOL"""
  return _OFDPA_python.OFDPA_BOOLp_value(*args)

def new_OFDPA_PROTECTION_INDEX_tp():
  """new_OFDPA_PROTECTION_INDEX_tp() -> OFDPA_PROTECTION_INDEX_t *"""
  return _OFDPA_python.new_OFDPA_PROTECTION_INDEX_tp()

def copy_OFDPA_PROTECTION_INDEX_tp(*args):
  """copy_OFDPA_PROTECTION_INDEX_tp(OFDPA_PROTECTION_INDEX_t value) -> OFDPA_PROTECTION_INDEX_t *"""
  return _OFDPA_python.copy_OFDPA_PROTECTION_INDEX_tp(*args)

def delete_OFDPA_PROTECTION_INDEX_tp(*args):
  """delete_OFDPA_PROTECTION_INDEX_tp(OFDPA_PROTECTION_INDEX_t * obj)"""
  return _OFDPA_python.delete_OFDPA_PROTECTION_INDEX_tp(*args)

def OFDPA_PROTECTION_INDEX_tp_assign(*args):
  """OFDPA_PROTECTION_INDEX_tp_assign(OFDPA_PROTECTION_INDEX_t * obj, OFDPA_PROTECTION_INDEX_t value)"""
  return _OFDPA_python.OFDPA_PROTECTION_INDEX_tp_assign(*args)

def OFDPA_PROTECTION_INDEX_tp_value(*args):
  """OFDPA_PROTECTION_INDEX_tp_value(OFDPA_PROTECTION_INDEX_t * obj) -> OFDPA_PROTECTION_INDEX_t"""
  return _OFDPA_python.OFDPA_PROTECTION_INDEX_tp_value(*args)

def new_OFDPA_PORT_TYPE_tp():
  """new_OFDPA_PORT_TYPE_tp() -> OFDPA_PORT_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_PORT_TYPE_tp()

def copy_OFDPA_PORT_TYPE_tp(*args):
  """copy_OFDPA_PORT_TYPE_tp(OFDPA_PORT_TYPE_t value) -> OFDPA_PORT_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_PORT_TYPE_tp(*args)

def delete_OFDPA_PORT_TYPE_tp(*args):
  """delete_OFDPA_PORT_TYPE_tp(OFDPA_PORT_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_PORT_TYPE_tp(*args)

def OFDPA_PORT_TYPE_tp_assign(*args):
  """OFDPA_PORT_TYPE_tp_assign(OFDPA_PORT_TYPE_t * obj, OFDPA_PORT_TYPE_t value)"""
  return _OFDPA_python.OFDPA_PORT_TYPE_tp_assign(*args)

def OFDPA_PORT_TYPE_tp_value(*args):
  """OFDPA_PORT_TYPE_tp_value(OFDPA_PORT_TYPE_t * obj) -> OFDPA_PORT_TYPE_t"""
  return _OFDPA_python.OFDPA_PORT_TYPE_tp_value(*args)

def new_OFDPA_MPLS_L2_PORT_TYPE_tp():
  """new_OFDPA_MPLS_L2_PORT_TYPE_tp() -> OFDPA_MPLS_L2_PORT_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_MPLS_L2_PORT_TYPE_tp()

def copy_OFDPA_MPLS_L2_PORT_TYPE_tp(*args):
  """copy_OFDPA_MPLS_L2_PORT_TYPE_tp(OFDPA_MPLS_L2_PORT_TYPE_t value) -> OFDPA_MPLS_L2_PORT_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_MPLS_L2_PORT_TYPE_tp(*args)

def delete_OFDPA_MPLS_L2_PORT_TYPE_tp(*args):
  """delete_OFDPA_MPLS_L2_PORT_TYPE_tp(OFDPA_MPLS_L2_PORT_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_MPLS_L2_PORT_TYPE_tp(*args)

def OFDPA_MPLS_L2_PORT_TYPE_tp_assign(*args):
  """OFDPA_MPLS_L2_PORT_TYPE_tp_assign(OFDPA_MPLS_L2_PORT_TYPE_t * obj, OFDPA_MPLS_L2_PORT_TYPE_t value)"""
  return _OFDPA_python.OFDPA_MPLS_L2_PORT_TYPE_tp_assign(*args)

def OFDPA_MPLS_L2_PORT_TYPE_tp_value(*args):
  """OFDPA_MPLS_L2_PORT_TYPE_tp_value(OFDPA_MPLS_L2_PORT_TYPE_t * obj) -> OFDPA_MPLS_L2_PORT_TYPE_t"""
  return _OFDPA_python.OFDPA_MPLS_L2_PORT_TYPE_tp_value(*args)

def new_OFDPA_QOS_COLORS_tp():
  """new_OFDPA_QOS_COLORS_tp() -> OFDPA_QOS_COLORS_t *"""
  return _OFDPA_python.new_OFDPA_QOS_COLORS_tp()

def copy_OFDPA_QOS_COLORS_tp(*args):
  """copy_OFDPA_QOS_COLORS_tp(OFDPA_QOS_COLORS_t value) -> OFDPA_QOS_COLORS_t *"""
  return _OFDPA_python.copy_OFDPA_QOS_COLORS_tp(*args)

def delete_OFDPA_QOS_COLORS_tp(*args):
  """delete_OFDPA_QOS_COLORS_tp(OFDPA_QOS_COLORS_t * obj)"""
  return _OFDPA_python.delete_OFDPA_QOS_COLORS_tp(*args)

def OFDPA_QOS_COLORS_tp_assign(*args):
  """OFDPA_QOS_COLORS_tp_assign(OFDPA_QOS_COLORS_t * obj, OFDPA_QOS_COLORS_t value)"""
  return _OFDPA_python.OFDPA_QOS_COLORS_tp_assign(*args)

def OFDPA_QOS_COLORS_tp_value(*args):
  """OFDPA_QOS_COLORS_tp_value(OFDPA_QOS_COLORS_t * obj) -> OFDPA_QOS_COLORS_t"""
  return _OFDPA_python.OFDPA_QOS_COLORS_tp_value(*args)

def new_OFDPA_CONTROL_tp():
  """new_OFDPA_CONTROL_tp() -> OFDPA_CONTROL_t *"""
  return _OFDPA_python.new_OFDPA_CONTROL_tp()

def copy_OFDPA_CONTROL_tp(*args):
  """copy_OFDPA_CONTROL_tp(OFDPA_CONTROL_t value) -> OFDPA_CONTROL_t *"""
  return _OFDPA_python.copy_OFDPA_CONTROL_tp(*args)

def delete_OFDPA_CONTROL_tp(*args):
  """delete_OFDPA_CONTROL_tp(OFDPA_CONTROL_t * obj)"""
  return _OFDPA_python.delete_OFDPA_CONTROL_tp(*args)

def OFDPA_CONTROL_tp_assign(*args):
  """OFDPA_CONTROL_tp_assign(OFDPA_CONTROL_t * obj, OFDPA_CONTROL_t value)"""
  return _OFDPA_python.OFDPA_CONTROL_tp_assign(*args)

def OFDPA_CONTROL_tp_value(*args):
  """OFDPA_CONTROL_tp_value(OFDPA_CONTROL_t * obj) -> OFDPA_CONTROL_t"""
  return _OFDPA_python.OFDPA_CONTROL_tp_value(*args)

def new_ofdpaComponentIds_tp():
  """new_ofdpaComponentIds_tp() -> ofdpaComponentIds_t *"""
  return _OFDPA_python.new_ofdpaComponentIds_tp()

def copy_ofdpaComponentIds_tp(*args):
  """copy_ofdpaComponentIds_tp(ofdpaComponentIds_t value) -> ofdpaComponentIds_t *"""
  return _OFDPA_python.copy_ofdpaComponentIds_tp(*args)

def delete_ofdpaComponentIds_tp(*args):
  """delete_ofdpaComponentIds_tp(ofdpaComponentIds_t * obj)"""
  return _OFDPA_python.delete_ofdpaComponentIds_tp(*args)

def ofdpaComponentIds_tp_assign(*args):
  """ofdpaComponentIds_tp_assign(ofdpaComponentIds_t * obj, ofdpaComponentIds_t value)"""
  return _OFDPA_python.ofdpaComponentIds_tp_assign(*args)

def ofdpaComponentIds_tp_value(*args):
  """ofdpaComponentIds_tp_value(ofdpaComponentIds_t * obj) -> ofdpaComponentIds_t"""
  return _OFDPA_python.ofdpaComponentIds_tp_value(*args)

def new_ofdpaDebugLevels_tp():
  """new_ofdpaDebugLevels_tp() -> ofdpaDebugLevels_t *"""
  return _OFDPA_python.new_ofdpaDebugLevels_tp()

def copy_ofdpaDebugLevels_tp(*args):
  """copy_ofdpaDebugLevels_tp(ofdpaDebugLevels_t value) -> ofdpaDebugLevels_t *"""
  return _OFDPA_python.copy_ofdpaDebugLevels_tp(*args)

def delete_ofdpaDebugLevels_tp(*args):
  """delete_ofdpaDebugLevels_tp(ofdpaDebugLevels_t * obj)"""
  return _OFDPA_python.delete_ofdpaDebugLevels_tp(*args)

def ofdpaDebugLevels_tp_assign(*args):
  """ofdpaDebugLevels_tp_assign(ofdpaDebugLevels_t * obj, ofdpaDebugLevels_t value)"""
  return _OFDPA_python.ofdpaDebugLevels_tp_assign(*args)

def ofdpaDebugLevels_tp_value(*args):
  """ofdpaDebugLevels_tp_value(ofdpaDebugLevels_t * obj) -> ofdpaDebugLevels_t"""
  return _OFDPA_python.ofdpaDebugLevels_tp_value(*args)

def new_OFDPA_TUNNELID_TYPE_tp():
  """new_OFDPA_TUNNELID_TYPE_tp() -> OFDPA_TUNNELID_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_TUNNELID_TYPE_tp()

def copy_OFDPA_TUNNELID_TYPE_tp(*args):
  """copy_OFDPA_TUNNELID_TYPE_tp(OFDPA_TUNNELID_TYPE_t value) -> OFDPA_TUNNELID_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_TUNNELID_TYPE_tp(*args)

def delete_OFDPA_TUNNELID_TYPE_tp(*args):
  """delete_OFDPA_TUNNELID_TYPE_tp(OFDPA_TUNNELID_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_TUNNELID_TYPE_tp(*args)

def OFDPA_TUNNELID_TYPE_tp_assign(*args):
  """OFDPA_TUNNELID_TYPE_tp_assign(OFDPA_TUNNELID_TYPE_t * obj, OFDPA_TUNNELID_TYPE_t value)"""
  return _OFDPA_python.OFDPA_TUNNELID_TYPE_tp_assign(*args)

def OFDPA_TUNNELID_TYPE_tp_value(*args):
  """OFDPA_TUNNELID_TYPE_tp_value(OFDPA_TUNNELID_TYPE_t * obj) -> OFDPA_TUNNELID_TYPE_t"""
  return _OFDPA_python.OFDPA_TUNNELID_TYPE_tp_value(*args)

def new_OFDPA_ACTION_TABLE_TYPE_tp():
  """new_OFDPA_ACTION_TABLE_TYPE_tp() -> OFDPA_ACTION_TABLE_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_ACTION_TABLE_TYPE_tp()

def copy_OFDPA_ACTION_TABLE_TYPE_tp(*args):
  """copy_OFDPA_ACTION_TABLE_TYPE_tp(OFDPA_ACTION_TABLE_TYPE_t value) -> OFDPA_ACTION_TABLE_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_ACTION_TABLE_TYPE_tp(*args)

def delete_OFDPA_ACTION_TABLE_TYPE_tp(*args):
  """delete_OFDPA_ACTION_TABLE_TYPE_tp(OFDPA_ACTION_TABLE_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_ACTION_TABLE_TYPE_tp(*args)

def OFDPA_ACTION_TABLE_TYPE_tp_assign(*args):
  """OFDPA_ACTION_TABLE_TYPE_tp_assign(OFDPA_ACTION_TABLE_TYPE_t * obj, OFDPA_ACTION_TABLE_TYPE_t value)"""
  return _OFDPA_python.OFDPA_ACTION_TABLE_TYPE_tp_assign(*args)

def OFDPA_ACTION_TABLE_TYPE_tp_value(*args):
  """OFDPA_ACTION_TABLE_TYPE_tp_value(OFDPA_ACTION_TABLE_TYPE_t * obj) -> OFDPA_ACTION_TABLE_TYPE_t"""
  return _OFDPA_python.OFDPA_ACTION_TABLE_TYPE_tp_value(*args)

def new_OFDPA_MPLS_TYPE_tp():
  """new_OFDPA_MPLS_TYPE_tp() -> OFDPA_MPLS_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_MPLS_TYPE_tp()

def copy_OFDPA_MPLS_TYPE_tp(*args):
  """copy_OFDPA_MPLS_TYPE_tp(OFDPA_MPLS_TYPE_t value) -> OFDPA_MPLS_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_MPLS_TYPE_tp(*args)

def delete_OFDPA_MPLS_TYPE_tp(*args):
  """delete_OFDPA_MPLS_TYPE_tp(OFDPA_MPLS_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_MPLS_TYPE_tp(*args)

def OFDPA_MPLS_TYPE_tp_assign(*args):
  """OFDPA_MPLS_TYPE_tp_assign(OFDPA_MPLS_TYPE_t * obj, OFDPA_MPLS_TYPE_t value)"""
  return _OFDPA_python.OFDPA_MPLS_TYPE_tp_assign(*args)

def OFDPA_MPLS_TYPE_tp_value(*args):
  """OFDPA_MPLS_TYPE_tp_value(OFDPA_MPLS_TYPE_t * obj) -> OFDPA_MPLS_TYPE_t"""
  return _OFDPA_python.OFDPA_MPLS_TYPE_tp_value(*args)

def new_OFDPA_FLOW_TABLE_ID_tp():
  """new_OFDPA_FLOW_TABLE_ID_tp() -> OFDPA_FLOW_TABLE_ID_t *"""
  return _OFDPA_python.new_OFDPA_FLOW_TABLE_ID_tp()

def copy_OFDPA_FLOW_TABLE_ID_tp(*args):
  """copy_OFDPA_FLOW_TABLE_ID_tp(OFDPA_FLOW_TABLE_ID_t value) -> OFDPA_FLOW_TABLE_ID_t *"""
  return _OFDPA_python.copy_OFDPA_FLOW_TABLE_ID_tp(*args)

def delete_OFDPA_FLOW_TABLE_ID_tp(*args):
  """delete_OFDPA_FLOW_TABLE_ID_tp(OFDPA_FLOW_TABLE_ID_t * obj)"""
  return _OFDPA_python.delete_OFDPA_FLOW_TABLE_ID_tp(*args)

def OFDPA_FLOW_TABLE_ID_tp_assign(*args):
  """OFDPA_FLOW_TABLE_ID_tp_assign(OFDPA_FLOW_TABLE_ID_t * obj, OFDPA_FLOW_TABLE_ID_t value)"""
  return _OFDPA_python.OFDPA_FLOW_TABLE_ID_tp_assign(*args)

def OFDPA_FLOW_TABLE_ID_tp_value(*args):
  """OFDPA_FLOW_TABLE_ID_tp_value(OFDPA_FLOW_TABLE_ID_t * obj) -> OFDPA_FLOW_TABLE_ID_t"""
  return _OFDPA_python.OFDPA_FLOW_TABLE_ID_tp_value(*args)

def new_OFDPA_GROUP_ENTRY_TYPE_tp():
  """new_OFDPA_GROUP_ENTRY_TYPE_tp() -> OFDPA_GROUP_ENTRY_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_GROUP_ENTRY_TYPE_tp()

def copy_OFDPA_GROUP_ENTRY_TYPE_tp(*args):
  """copy_OFDPA_GROUP_ENTRY_TYPE_tp(OFDPA_GROUP_ENTRY_TYPE_t value) -> OFDPA_GROUP_ENTRY_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_GROUP_ENTRY_TYPE_tp(*args)

def delete_OFDPA_GROUP_ENTRY_TYPE_tp(*args):
  """delete_OFDPA_GROUP_ENTRY_TYPE_tp(OFDPA_GROUP_ENTRY_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_GROUP_ENTRY_TYPE_tp(*args)

def OFDPA_GROUP_ENTRY_TYPE_tp_assign(*args):
  """OFDPA_GROUP_ENTRY_TYPE_tp_assign(OFDPA_GROUP_ENTRY_TYPE_t * obj, OFDPA_GROUP_ENTRY_TYPE_t value)"""
  return _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_tp_assign(*args)

def OFDPA_GROUP_ENTRY_TYPE_tp_value(*args):
  """OFDPA_GROUP_ENTRY_TYPE_tp_value(OFDPA_GROUP_ENTRY_TYPE_t * obj) -> OFDPA_GROUP_ENTRY_TYPE_t"""
  return _OFDPA_python.OFDPA_GROUP_ENTRY_TYPE_tp_value(*args)

def new_OFDPA_L2_OVERLAY_SUBTYPE_tp():
  """new_OFDPA_L2_OVERLAY_SUBTYPE_tp() -> OFDPA_L2_OVERLAY_SUBTYPE_t *"""
  return _OFDPA_python.new_OFDPA_L2_OVERLAY_SUBTYPE_tp()

def copy_OFDPA_L2_OVERLAY_SUBTYPE_tp(*args):
  """copy_OFDPA_L2_OVERLAY_SUBTYPE_tp(OFDPA_L2_OVERLAY_SUBTYPE_t value) -> OFDPA_L2_OVERLAY_SUBTYPE_t *"""
  return _OFDPA_python.copy_OFDPA_L2_OVERLAY_SUBTYPE_tp(*args)

def delete_OFDPA_L2_OVERLAY_SUBTYPE_tp(*args):
  """delete_OFDPA_L2_OVERLAY_SUBTYPE_tp(OFDPA_L2_OVERLAY_SUBTYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_L2_OVERLAY_SUBTYPE_tp(*args)

def OFDPA_L2_OVERLAY_SUBTYPE_tp_assign(*args):
  """OFDPA_L2_OVERLAY_SUBTYPE_tp_assign(OFDPA_L2_OVERLAY_SUBTYPE_t * obj, OFDPA_L2_OVERLAY_SUBTYPE_t value)"""
  return _OFDPA_python.OFDPA_L2_OVERLAY_SUBTYPE_tp_assign(*args)

def OFDPA_L2_OVERLAY_SUBTYPE_tp_value(*args):
  """OFDPA_L2_OVERLAY_SUBTYPE_tp_value(OFDPA_L2_OVERLAY_SUBTYPE_t * obj) -> OFDPA_L2_OVERLAY_SUBTYPE_t"""
  return _OFDPA_python.OFDPA_L2_OVERLAY_SUBTYPE_tp_value(*args)

def new_OFDPA_MPLS_LABEL_SUBTYPE_tp():
  """new_OFDPA_MPLS_LABEL_SUBTYPE_tp() -> OFDPA_MPLS_LABEL_SUBTYPE_t *"""
  return _OFDPA_python.new_OFDPA_MPLS_LABEL_SUBTYPE_tp()

def copy_OFDPA_MPLS_LABEL_SUBTYPE_tp(*args):
  """copy_OFDPA_MPLS_LABEL_SUBTYPE_tp(OFDPA_MPLS_LABEL_SUBTYPE_t value) -> OFDPA_MPLS_LABEL_SUBTYPE_t *"""
  return _OFDPA_python.copy_OFDPA_MPLS_LABEL_SUBTYPE_tp(*args)

def delete_OFDPA_MPLS_LABEL_SUBTYPE_tp(*args):
  """delete_OFDPA_MPLS_LABEL_SUBTYPE_tp(OFDPA_MPLS_LABEL_SUBTYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_MPLS_LABEL_SUBTYPE_tp(*args)

def OFDPA_MPLS_LABEL_SUBTYPE_tp_assign(*args):
  """OFDPA_MPLS_LABEL_SUBTYPE_tp_assign(OFDPA_MPLS_LABEL_SUBTYPE_t * obj, OFDPA_MPLS_LABEL_SUBTYPE_t value)"""
  return _OFDPA_python.OFDPA_MPLS_LABEL_SUBTYPE_tp_assign(*args)

def OFDPA_MPLS_LABEL_SUBTYPE_tp_value(*args):
  """OFDPA_MPLS_LABEL_SUBTYPE_tp_value(OFDPA_MPLS_LABEL_SUBTYPE_t * obj) -> OFDPA_MPLS_LABEL_SUBTYPE_t"""
  return _OFDPA_python.OFDPA_MPLS_LABEL_SUBTYPE_tp_value(*args)

def new_OFDPA_MPLS_FORWARDING_SUBTYPE_tp():
  """new_OFDPA_MPLS_FORWARDING_SUBTYPE_tp() -> OFDPA_MPLS_FORWARDING_SUBTYPE_t *"""
  return _OFDPA_python.new_OFDPA_MPLS_FORWARDING_SUBTYPE_tp()

def copy_OFDPA_MPLS_FORWARDING_SUBTYPE_tp(*args):
  """copy_OFDPA_MPLS_FORWARDING_SUBTYPE_tp(OFDPA_MPLS_FORWARDING_SUBTYPE_t value) -> OFDPA_MPLS_FORWARDING_SUBTYPE_t *"""
  return _OFDPA_python.copy_OFDPA_MPLS_FORWARDING_SUBTYPE_tp(*args)

def delete_OFDPA_MPLS_FORWARDING_SUBTYPE_tp(*args):
  """delete_OFDPA_MPLS_FORWARDING_SUBTYPE_tp(OFDPA_MPLS_FORWARDING_SUBTYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_MPLS_FORWARDING_SUBTYPE_tp(*args)

def OFDPA_MPLS_FORWARDING_SUBTYPE_tp_assign(*args):
  """OFDPA_MPLS_FORWARDING_SUBTYPE_tp_assign(OFDPA_MPLS_FORWARDING_SUBTYPE_t * obj, OFDPA_MPLS_FORWARDING_SUBTYPE_t value)"""
  return _OFDPA_python.OFDPA_MPLS_FORWARDING_SUBTYPE_tp_assign(*args)

def OFDPA_MPLS_FORWARDING_SUBTYPE_tp_value(*args):
  """OFDPA_MPLS_FORWARDING_SUBTYPE_tp_value(OFDPA_MPLS_FORWARDING_SUBTYPE_t * obj) -> OFDPA_MPLS_FORWARDING_SUBTYPE_t"""
  return _OFDPA_python.OFDPA_MPLS_FORWARDING_SUBTYPE_tp_value(*args)

def new_OFDPA_PORT_CONFIG_tp():
  """new_OFDPA_PORT_CONFIG_tp() -> OFDPA_PORT_CONFIG_t *"""
  return _OFDPA_python.new_OFDPA_PORT_CONFIG_tp()

def copy_OFDPA_PORT_CONFIG_tp(*args):
  """copy_OFDPA_PORT_CONFIG_tp(OFDPA_PORT_CONFIG_t value) -> OFDPA_PORT_CONFIG_t *"""
  return _OFDPA_python.copy_OFDPA_PORT_CONFIG_tp(*args)

def delete_OFDPA_PORT_CONFIG_tp(*args):
  """delete_OFDPA_PORT_CONFIG_tp(OFDPA_PORT_CONFIG_t * obj)"""
  return _OFDPA_python.delete_OFDPA_PORT_CONFIG_tp(*args)

def OFDPA_PORT_CONFIG_tp_assign(*args):
  """OFDPA_PORT_CONFIG_tp_assign(OFDPA_PORT_CONFIG_t * obj, OFDPA_PORT_CONFIG_t value)"""
  return _OFDPA_python.OFDPA_PORT_CONFIG_tp_assign(*args)

def OFDPA_PORT_CONFIG_tp_value(*args):
  """OFDPA_PORT_CONFIG_tp_value(OFDPA_PORT_CONFIG_t * obj) -> OFDPA_PORT_CONFIG_t"""
  return _OFDPA_python.OFDPA_PORT_CONFIG_tp_value(*args)

def new_OFDPA_PORT_STATE_tp():
  """new_OFDPA_PORT_STATE_tp() -> OFDPA_PORT_STATE_t *"""
  return _OFDPA_python.new_OFDPA_PORT_STATE_tp()

def copy_OFDPA_PORT_STATE_tp(*args):
  """copy_OFDPA_PORT_STATE_tp(OFDPA_PORT_STATE_t value) -> OFDPA_PORT_STATE_t *"""
  return _OFDPA_python.copy_OFDPA_PORT_STATE_tp(*args)

def delete_OFDPA_PORT_STATE_tp(*args):
  """delete_OFDPA_PORT_STATE_tp(OFDPA_PORT_STATE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_PORT_STATE_tp(*args)

def OFDPA_PORT_STATE_tp_assign(*args):
  """OFDPA_PORT_STATE_tp_assign(OFDPA_PORT_STATE_t * obj, OFDPA_PORT_STATE_t value)"""
  return _OFDPA_python.OFDPA_PORT_STATE_tp_assign(*args)

def OFDPA_PORT_STATE_tp_value(*args):
  """OFDPA_PORT_STATE_tp_value(OFDPA_PORT_STATE_t * obj) -> OFDPA_PORT_STATE_t"""
  return _OFDPA_python.OFDPA_PORT_STATE_tp_value(*args)

def new_OFDPA_PORT_FEATURE_tp():
  """new_OFDPA_PORT_FEATURE_tp() -> OFDPA_PORT_FEATURE_t *"""
  return _OFDPA_python.new_OFDPA_PORT_FEATURE_tp()

def copy_OFDPA_PORT_FEATURE_tp(*args):
  """copy_OFDPA_PORT_FEATURE_tp(OFDPA_PORT_FEATURE_t value) -> OFDPA_PORT_FEATURE_t *"""
  return _OFDPA_python.copy_OFDPA_PORT_FEATURE_tp(*args)

def delete_OFDPA_PORT_FEATURE_tp(*args):
  """delete_OFDPA_PORT_FEATURE_tp(OFDPA_PORT_FEATURE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_PORT_FEATURE_tp(*args)

def OFDPA_PORT_FEATURE_tp_assign(*args):
  """OFDPA_PORT_FEATURE_tp_assign(OFDPA_PORT_FEATURE_t * obj, OFDPA_PORT_FEATURE_t value)"""
  return _OFDPA_python.OFDPA_PORT_FEATURE_tp_assign(*args)

def OFDPA_PORT_FEATURE_tp_value(*args):
  """OFDPA_PORT_FEATURE_tp_value(OFDPA_PORT_FEATURE_t * obj) -> OFDPA_PORT_FEATURE_t"""
  return _OFDPA_python.OFDPA_PORT_FEATURE_tp_value(*args)

def new_OFDPA_PACKET_IN_REASON_tp():
  """new_OFDPA_PACKET_IN_REASON_tp() -> OFDPA_PACKET_IN_REASON_t *"""
  return _OFDPA_python.new_OFDPA_PACKET_IN_REASON_tp()

def copy_OFDPA_PACKET_IN_REASON_tp(*args):
  """copy_OFDPA_PACKET_IN_REASON_tp(OFDPA_PACKET_IN_REASON_t value) -> OFDPA_PACKET_IN_REASON_t *"""
  return _OFDPA_python.copy_OFDPA_PACKET_IN_REASON_tp(*args)

def delete_OFDPA_PACKET_IN_REASON_tp(*args):
  """delete_OFDPA_PACKET_IN_REASON_tp(OFDPA_PACKET_IN_REASON_t * obj)"""
  return _OFDPA_python.delete_OFDPA_PACKET_IN_REASON_tp(*args)

def OFDPA_PACKET_IN_REASON_tp_assign(*args):
  """OFDPA_PACKET_IN_REASON_tp_assign(OFDPA_PACKET_IN_REASON_t * obj, OFDPA_PACKET_IN_REASON_t value)"""
  return _OFDPA_python.OFDPA_PACKET_IN_REASON_tp_assign(*args)

def OFDPA_PACKET_IN_REASON_tp_value(*args):
  """OFDPA_PACKET_IN_REASON_tp_value(OFDPA_PACKET_IN_REASON_t * obj) -> OFDPA_PACKET_IN_REASON_t"""
  return _OFDPA_python.OFDPA_PACKET_IN_REASON_tp_value(*args)

def new_OFDPA_PORT_EVENT_MASK_tp():
  """new_OFDPA_PORT_EVENT_MASK_tp() -> OFDPA_PORT_EVENT_MASK_t *"""
  return _OFDPA_python.new_OFDPA_PORT_EVENT_MASK_tp()

def copy_OFDPA_PORT_EVENT_MASK_tp(*args):
  """copy_OFDPA_PORT_EVENT_MASK_tp(OFDPA_PORT_EVENT_MASK_t value) -> OFDPA_PORT_EVENT_MASK_t *"""
  return _OFDPA_python.copy_OFDPA_PORT_EVENT_MASK_tp(*args)

def delete_OFDPA_PORT_EVENT_MASK_tp(*args):
  """delete_OFDPA_PORT_EVENT_MASK_tp(OFDPA_PORT_EVENT_MASK_t * obj)"""
  return _OFDPA_python.delete_OFDPA_PORT_EVENT_MASK_tp(*args)

def OFDPA_PORT_EVENT_MASK_tp_assign(*args):
  """OFDPA_PORT_EVENT_MASK_tp_assign(OFDPA_PORT_EVENT_MASK_t * obj, OFDPA_PORT_EVENT_MASK_t value)"""
  return _OFDPA_python.OFDPA_PORT_EVENT_MASK_tp_assign(*args)

def OFDPA_PORT_EVENT_MASK_tp_value(*args):
  """OFDPA_PORT_EVENT_MASK_tp_value(OFDPA_PORT_EVENT_MASK_t * obj) -> OFDPA_PORT_EVENT_MASK_t"""
  return _OFDPA_python.OFDPA_PORT_EVENT_MASK_tp_value(*args)

def new_OFDPA_FLOW_EVENT_MASK_tp():
  """new_OFDPA_FLOW_EVENT_MASK_tp() -> OFDPA_FLOW_EVENT_MASK_t *"""
  return _OFDPA_python.new_OFDPA_FLOW_EVENT_MASK_tp()

def copy_OFDPA_FLOW_EVENT_MASK_tp(*args):
  """copy_OFDPA_FLOW_EVENT_MASK_tp(OFDPA_FLOW_EVENT_MASK_t value) -> OFDPA_FLOW_EVENT_MASK_t *"""
  return _OFDPA_python.copy_OFDPA_FLOW_EVENT_MASK_tp(*args)

def delete_OFDPA_FLOW_EVENT_MASK_tp(*args):
  """delete_OFDPA_FLOW_EVENT_MASK_tp(OFDPA_FLOW_EVENT_MASK_t * obj)"""
  return _OFDPA_python.delete_OFDPA_FLOW_EVENT_MASK_tp(*args)

def OFDPA_FLOW_EVENT_MASK_tp_assign(*args):
  """OFDPA_FLOW_EVENT_MASK_tp_assign(OFDPA_FLOW_EVENT_MASK_t * obj, OFDPA_FLOW_EVENT_MASK_t value)"""
  return _OFDPA_python.OFDPA_FLOW_EVENT_MASK_tp_assign(*args)

def OFDPA_FLOW_EVENT_MASK_tp_value(*args):
  """OFDPA_FLOW_EVENT_MASK_tp_value(OFDPA_FLOW_EVENT_MASK_t * obj) -> OFDPA_FLOW_EVENT_MASK_t"""
  return _OFDPA_python.OFDPA_FLOW_EVENT_MASK_tp_value(*args)

def new_OFDPA_TUNNEL_PORT_TYPE_tp():
  """new_OFDPA_TUNNEL_PORT_TYPE_tp() -> OFDPA_TUNNEL_PORT_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_TUNNEL_PORT_TYPE_tp()

def copy_OFDPA_TUNNEL_PORT_TYPE_tp(*args):
  """copy_OFDPA_TUNNEL_PORT_TYPE_tp(OFDPA_TUNNEL_PORT_TYPE_t value) -> OFDPA_TUNNEL_PORT_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_TUNNEL_PORT_TYPE_tp(*args)

def delete_OFDPA_TUNNEL_PORT_TYPE_tp(*args):
  """delete_OFDPA_TUNNEL_PORT_TYPE_tp(OFDPA_TUNNEL_PORT_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_TUNNEL_PORT_TYPE_tp(*args)

def OFDPA_TUNNEL_PORT_TYPE_tp_assign(*args):
  """OFDPA_TUNNEL_PORT_TYPE_tp_assign(OFDPA_TUNNEL_PORT_TYPE_t * obj, OFDPA_TUNNEL_PORT_TYPE_t value)"""
  return _OFDPA_python.OFDPA_TUNNEL_PORT_TYPE_tp_assign(*args)

def OFDPA_TUNNEL_PORT_TYPE_tp_value(*args):
  """OFDPA_TUNNEL_PORT_TYPE_tp_value(OFDPA_TUNNEL_PORT_TYPE_t * obj) -> OFDPA_TUNNEL_PORT_TYPE_t"""
  return _OFDPA_python.OFDPA_TUNNEL_PORT_TYPE_tp_value(*args)

def new_OFDPA_TUNNEL_PROTO_tp():
  """new_OFDPA_TUNNEL_PROTO_tp() -> OFDPA_TUNNEL_PROTO_t *"""
  return _OFDPA_python.new_OFDPA_TUNNEL_PROTO_tp()

def copy_OFDPA_TUNNEL_PROTO_tp(*args):
  """copy_OFDPA_TUNNEL_PROTO_tp(OFDPA_TUNNEL_PROTO_t value) -> OFDPA_TUNNEL_PROTO_t *"""
  return _OFDPA_python.copy_OFDPA_TUNNEL_PROTO_tp(*args)

def delete_OFDPA_TUNNEL_PROTO_tp(*args):
  """delete_OFDPA_TUNNEL_PROTO_tp(OFDPA_TUNNEL_PROTO_t * obj)"""
  return _OFDPA_python.delete_OFDPA_TUNNEL_PROTO_tp(*args)

def OFDPA_TUNNEL_PROTO_tp_assign(*args):
  """OFDPA_TUNNEL_PROTO_tp_assign(OFDPA_TUNNEL_PROTO_t * obj, OFDPA_TUNNEL_PROTO_t value)"""
  return _OFDPA_python.OFDPA_TUNNEL_PROTO_tp_assign(*args)

def OFDPA_TUNNEL_PROTO_tp_value(*args):
  """OFDPA_TUNNEL_PROTO_tp_value(OFDPA_TUNNEL_PROTO_t * obj) -> OFDPA_TUNNEL_PROTO_t"""
  return _OFDPA_python.OFDPA_TUNNEL_PROTO_tp_value(*args)

def new_OFDPA_METER_RATE_UNIT_tp():
  """new_OFDPA_METER_RATE_UNIT_tp() -> OFDPA_METER_RATE_UNIT_t *"""
  return _OFDPA_python.new_OFDPA_METER_RATE_UNIT_tp()

def copy_OFDPA_METER_RATE_UNIT_tp(*args):
  """copy_OFDPA_METER_RATE_UNIT_tp(OFDPA_METER_RATE_UNIT_t value) -> OFDPA_METER_RATE_UNIT_t *"""
  return _OFDPA_python.copy_OFDPA_METER_RATE_UNIT_tp(*args)

def delete_OFDPA_METER_RATE_UNIT_tp(*args):
  """delete_OFDPA_METER_RATE_UNIT_tp(OFDPA_METER_RATE_UNIT_t * obj)"""
  return _OFDPA_python.delete_OFDPA_METER_RATE_UNIT_tp(*args)

def OFDPA_METER_RATE_UNIT_tp_assign(*args):
  """OFDPA_METER_RATE_UNIT_tp_assign(OFDPA_METER_RATE_UNIT_t * obj, OFDPA_METER_RATE_UNIT_t value)"""
  return _OFDPA_python.OFDPA_METER_RATE_UNIT_tp_assign(*args)

def OFDPA_METER_RATE_UNIT_tp_value(*args):
  """OFDPA_METER_RATE_UNIT_tp_value(OFDPA_METER_RATE_UNIT_t * obj) -> OFDPA_METER_RATE_UNIT_t"""
  return _OFDPA_python.OFDPA_METER_RATE_UNIT_tp_value(*args)

def new_OFDPA_METER_COLOR_MODE_tp():
  """new_OFDPA_METER_COLOR_MODE_tp() -> OFDPA_METER_COLOR_MODE_t *"""
  return _OFDPA_python.new_OFDPA_METER_COLOR_MODE_tp()

def copy_OFDPA_METER_COLOR_MODE_tp(*args):
  """copy_OFDPA_METER_COLOR_MODE_tp(OFDPA_METER_COLOR_MODE_t value) -> OFDPA_METER_COLOR_MODE_t *"""
  return _OFDPA_python.copy_OFDPA_METER_COLOR_MODE_tp(*args)

def delete_OFDPA_METER_COLOR_MODE_tp(*args):
  """delete_OFDPA_METER_COLOR_MODE_tp(OFDPA_METER_COLOR_MODE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_METER_COLOR_MODE_tp(*args)

def OFDPA_METER_COLOR_MODE_tp_assign(*args):
  """OFDPA_METER_COLOR_MODE_tp_assign(OFDPA_METER_COLOR_MODE_t * obj, OFDPA_METER_COLOR_MODE_t value)"""
  return _OFDPA_python.OFDPA_METER_COLOR_MODE_tp_assign(*args)

def OFDPA_METER_COLOR_MODE_tp_value(*args):
  """OFDPA_METER_COLOR_MODE_tp_value(OFDPA_METER_COLOR_MODE_t * obj) -> OFDPA_METER_COLOR_MODE_t"""
  return _OFDPA_python.OFDPA_METER_COLOR_MODE_tp_value(*args)

def new_OFDPA_METER_TYPE_tp():
  """new_OFDPA_METER_TYPE_tp() -> OFDPA_METER_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_METER_TYPE_tp()

def copy_OFDPA_METER_TYPE_tp(*args):
  """copy_OFDPA_METER_TYPE_tp(OFDPA_METER_TYPE_t value) -> OFDPA_METER_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_METER_TYPE_tp(*args)

def delete_OFDPA_METER_TYPE_tp(*args):
  """delete_OFDPA_METER_TYPE_tp(OFDPA_METER_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_METER_TYPE_tp(*args)

def OFDPA_METER_TYPE_tp_assign(*args):
  """OFDPA_METER_TYPE_tp_assign(OFDPA_METER_TYPE_t * obj, OFDPA_METER_TYPE_t value)"""
  return _OFDPA_python.OFDPA_METER_TYPE_tp_assign(*args)

def OFDPA_METER_TYPE_tp_value(*args):
  """OFDPA_METER_TYPE_tp_value(OFDPA_METER_TYPE_t * obj) -> OFDPA_METER_TYPE_t"""
  return _OFDPA_python.OFDPA_METER_TYPE_tp_value(*args)

def new_OFDPA_TCM_METER_MODE_tp():
  """new_OFDPA_TCM_METER_MODE_tp() -> OFDPA_TCM_METER_MODE_t *"""
  return _OFDPA_python.new_OFDPA_TCM_METER_MODE_tp()

def copy_OFDPA_TCM_METER_MODE_tp(*args):
  """copy_OFDPA_TCM_METER_MODE_tp(OFDPA_TCM_METER_MODE_t value) -> OFDPA_TCM_METER_MODE_t *"""
  return _OFDPA_python.copy_OFDPA_TCM_METER_MODE_tp(*args)

def delete_OFDPA_TCM_METER_MODE_tp(*args):
  """delete_OFDPA_TCM_METER_MODE_tp(OFDPA_TCM_METER_MODE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_TCM_METER_MODE_tp(*args)

def OFDPA_TCM_METER_MODE_tp_assign(*args):
  """OFDPA_TCM_METER_MODE_tp_assign(OFDPA_TCM_METER_MODE_t * obj, OFDPA_TCM_METER_MODE_t value)"""
  return _OFDPA_python.OFDPA_TCM_METER_MODE_tp_assign(*args)

def OFDPA_TCM_METER_MODE_tp_value(*args):
  """OFDPA_TCM_METER_MODE_tp_value(OFDPA_TCM_METER_MODE_t * obj) -> OFDPA_TCM_METER_MODE_t"""
  return _OFDPA_python.OFDPA_TCM_METER_MODE_tp_value(*args)

def new_OFDPA_MP_DIRECTION_tp():
  """new_OFDPA_MP_DIRECTION_tp() -> OFDPA_MP_DIRECTION_t *"""
  return _OFDPA_python.new_OFDPA_MP_DIRECTION_tp()

def copy_OFDPA_MP_DIRECTION_tp(*args):
  """copy_OFDPA_MP_DIRECTION_tp(OFDPA_MP_DIRECTION_t value) -> OFDPA_MP_DIRECTION_t *"""
  return _OFDPA_python.copy_OFDPA_MP_DIRECTION_tp(*args)

def delete_OFDPA_MP_DIRECTION_tp(*args):
  """delete_OFDPA_MP_DIRECTION_tp(OFDPA_MP_DIRECTION_t * obj)"""
  return _OFDPA_python.delete_OFDPA_MP_DIRECTION_tp(*args)

def OFDPA_MP_DIRECTION_tp_assign(*args):
  """OFDPA_MP_DIRECTION_tp_assign(OFDPA_MP_DIRECTION_t * obj, OFDPA_MP_DIRECTION_t value)"""
  return _OFDPA_python.OFDPA_MP_DIRECTION_tp_assign(*args)

def OFDPA_MP_DIRECTION_tp_value(*args):
  """OFDPA_MP_DIRECTION_tp_value(OFDPA_MP_DIRECTION_t * obj) -> OFDPA_MP_DIRECTION_t"""
  return _OFDPA_python.OFDPA_MP_DIRECTION_tp_value(*args)

def new_OFDPA_CCM_INTERVAL_tp():
  """new_OFDPA_CCM_INTERVAL_tp() -> OFDPA_CCM_INTERVAL_t *"""
  return _OFDPA_python.new_OFDPA_CCM_INTERVAL_tp()

def copy_OFDPA_CCM_INTERVAL_tp(*args):
  """copy_OFDPA_CCM_INTERVAL_tp(OFDPA_CCM_INTERVAL_t value) -> OFDPA_CCM_INTERVAL_t *"""
  return _OFDPA_python.copy_OFDPA_CCM_INTERVAL_tp(*args)

def delete_OFDPA_CCM_INTERVAL_tp(*args):
  """delete_OFDPA_CCM_INTERVAL_tp(OFDPA_CCM_INTERVAL_t * obj)"""
  return _OFDPA_python.delete_OFDPA_CCM_INTERVAL_tp(*args)

def OFDPA_CCM_INTERVAL_tp_assign(*args):
  """OFDPA_CCM_INTERVAL_tp_assign(OFDPA_CCM_INTERVAL_t * obj, OFDPA_CCM_INTERVAL_t value)"""
  return _OFDPA_python.OFDPA_CCM_INTERVAL_tp_assign(*args)

def OFDPA_CCM_INTERVAL_tp_value(*args):
  """OFDPA_CCM_INTERVAL_tp_value(OFDPA_CCM_INTERVAL_t * obj) -> OFDPA_CCM_INTERVAL_t"""
  return _OFDPA_python.OFDPA_CCM_INTERVAL_tp_value(*args)

def new_OFDPA_OAM_MEG_TYPE_tp():
  """new_OFDPA_OAM_MEG_TYPE_tp() -> OFDPA_OAM_MEG_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_OAM_MEG_TYPE_tp()

def copy_OFDPA_OAM_MEG_TYPE_tp(*args):
  """copy_OFDPA_OAM_MEG_TYPE_tp(OFDPA_OAM_MEG_TYPE_t value) -> OFDPA_OAM_MEG_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_MEG_TYPE_tp(*args)

def delete_OFDPA_OAM_MEG_TYPE_tp(*args):
  """delete_OFDPA_OAM_MEG_TYPE_tp(OFDPA_OAM_MEG_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_MEG_TYPE_tp(*args)

def OFDPA_OAM_MEG_TYPE_tp_assign(*args):
  """OFDPA_OAM_MEG_TYPE_tp_assign(OFDPA_OAM_MEG_TYPE_t * obj, OFDPA_OAM_MEG_TYPE_t value)"""
  return _OFDPA_python.OFDPA_OAM_MEG_TYPE_tp_assign(*args)

def OFDPA_OAM_MEG_TYPE_tp_value(*args):
  """OFDPA_OAM_MEG_TYPE_tp_value(OFDPA_OAM_MEG_TYPE_t * obj) -> OFDPA_OAM_MEG_TYPE_t"""
  return _OFDPA_python.OFDPA_OAM_MEG_TYPE_tp_value(*args)

def new_OFDPA_OAM_PM_TOOL_TYPE_tp():
  """new_OFDPA_OAM_PM_TOOL_TYPE_tp() -> OFDPA_OAM_PM_TOOL_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_OAM_PM_TOOL_TYPE_tp()

def copy_OFDPA_OAM_PM_TOOL_TYPE_tp(*args):
  """copy_OFDPA_OAM_PM_TOOL_TYPE_tp(OFDPA_OAM_PM_TOOL_TYPE_t value) -> OFDPA_OAM_PM_TOOL_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_PM_TOOL_TYPE_tp(*args)

def delete_OFDPA_OAM_PM_TOOL_TYPE_tp(*args):
  """delete_OFDPA_OAM_PM_TOOL_TYPE_tp(OFDPA_OAM_PM_TOOL_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_PM_TOOL_TYPE_tp(*args)

def OFDPA_OAM_PM_TOOL_TYPE_tp_assign(*args):
  """OFDPA_OAM_PM_TOOL_TYPE_tp_assign(OFDPA_OAM_PM_TOOL_TYPE_t * obj, OFDPA_OAM_PM_TOOL_TYPE_t value)"""
  return _OFDPA_python.OFDPA_OAM_PM_TOOL_TYPE_tp_assign(*args)

def OFDPA_OAM_PM_TOOL_TYPE_tp_value(*args):
  """OFDPA_OAM_PM_TOOL_TYPE_tp_value(OFDPA_OAM_PM_TOOL_TYPE_t * obj) -> OFDPA_OAM_PM_TOOL_TYPE_t"""
  return _OFDPA_python.OFDPA_OAM_PM_TOOL_TYPE_tp_value(*args)

def new_OFDPA_OAM_MP_TYPE_tp():
  """new_OFDPA_OAM_MP_TYPE_tp() -> OFDPA_OAM_MP_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_OAM_MP_TYPE_tp()

def copy_OFDPA_OAM_MP_TYPE_tp(*args):
  """copy_OFDPA_OAM_MP_TYPE_tp(OFDPA_OAM_MP_TYPE_t value) -> OFDPA_OAM_MP_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_MP_TYPE_tp(*args)

def delete_OFDPA_OAM_MP_TYPE_tp(*args):
  """delete_OFDPA_OAM_MP_TYPE_tp(OFDPA_OAM_MP_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_MP_TYPE_tp(*args)

def OFDPA_OAM_MP_TYPE_tp_assign(*args):
  """OFDPA_OAM_MP_TYPE_tp_assign(OFDPA_OAM_MP_TYPE_t * obj, OFDPA_OAM_MP_TYPE_t value)"""
  return _OFDPA_python.OFDPA_OAM_MP_TYPE_tp_assign(*args)

def OFDPA_OAM_MP_TYPE_tp_value(*args):
  """OFDPA_OAM_MP_TYPE_tp_value(OFDPA_OAM_MP_TYPE_t * obj) -> OFDPA_OAM_MP_TYPE_t"""
  return _OFDPA_python.OFDPA_OAM_MP_TYPE_tp_value(*args)

def new_OFDPA_OAM_PM_ROLE_tp():
  """new_OFDPA_OAM_PM_ROLE_tp() -> OFDPA_OAM_PM_ROLE_t *"""
  return _OFDPA_python.new_OFDPA_OAM_PM_ROLE_tp()

def copy_OFDPA_OAM_PM_ROLE_tp(*args):
  """copy_OFDPA_OAM_PM_ROLE_tp(OFDPA_OAM_PM_ROLE_t value) -> OFDPA_OAM_PM_ROLE_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_PM_ROLE_tp(*args)

def delete_OFDPA_OAM_PM_ROLE_tp(*args):
  """delete_OFDPA_OAM_PM_ROLE_tp(OFDPA_OAM_PM_ROLE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_PM_ROLE_tp(*args)

def OFDPA_OAM_PM_ROLE_tp_assign(*args):
  """OFDPA_OAM_PM_ROLE_tp_assign(OFDPA_OAM_PM_ROLE_t * obj, OFDPA_OAM_PM_ROLE_t value)"""
  return _OFDPA_python.OFDPA_OAM_PM_ROLE_tp_assign(*args)

def OFDPA_OAM_PM_ROLE_tp_value(*args):
  """OFDPA_OAM_PM_ROLE_tp_value(OFDPA_OAM_PM_ROLE_t * obj) -> OFDPA_OAM_PM_ROLE_t"""
  return _OFDPA_python.OFDPA_OAM_PM_ROLE_tp_value(*args)

def new_OFDPA_OAM_PM_STATE_tp():
  """new_OFDPA_OAM_PM_STATE_tp() -> OFDPA_OAM_PM_STATE_t *"""
  return _OFDPA_python.new_OFDPA_OAM_PM_STATE_tp()

def copy_OFDPA_OAM_PM_STATE_tp(*args):
  """copy_OFDPA_OAM_PM_STATE_tp(OFDPA_OAM_PM_STATE_t value) -> OFDPA_OAM_PM_STATE_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_PM_STATE_tp(*args)

def delete_OFDPA_OAM_PM_STATE_tp(*args):
  """delete_OFDPA_OAM_PM_STATE_tp(OFDPA_OAM_PM_STATE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_PM_STATE_tp(*args)

def OFDPA_OAM_PM_STATE_tp_assign(*args):
  """OFDPA_OAM_PM_STATE_tp_assign(OFDPA_OAM_PM_STATE_t * obj, OFDPA_OAM_PM_STATE_t value)"""
  return _OFDPA_python.OFDPA_OAM_PM_STATE_tp_assign(*args)

def OFDPA_OAM_PM_STATE_tp_value(*args):
  """OFDPA_OAM_PM_STATE_tp_value(OFDPA_OAM_PM_STATE_t * obj) -> OFDPA_OAM_PM_STATE_t"""
  return _OFDPA_python.OFDPA_OAM_PM_STATE_tp_value(*args)

def new_OFDPA_OAM_DM_TYPE_tp():
  """new_OFDPA_OAM_DM_TYPE_tp() -> OFDPA_OAM_DM_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_OAM_DM_TYPE_tp()

def copy_OFDPA_OAM_DM_TYPE_tp(*args):
  """copy_OFDPA_OAM_DM_TYPE_tp(OFDPA_OAM_DM_TYPE_t value) -> OFDPA_OAM_DM_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_DM_TYPE_tp(*args)

def delete_OFDPA_OAM_DM_TYPE_tp(*args):
  """delete_OFDPA_OAM_DM_TYPE_tp(OFDPA_OAM_DM_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_DM_TYPE_tp(*args)

def OFDPA_OAM_DM_TYPE_tp_assign(*args):
  """OFDPA_OAM_DM_TYPE_tp_assign(OFDPA_OAM_DM_TYPE_t * obj, OFDPA_OAM_DM_TYPE_t value)"""
  return _OFDPA_python.OFDPA_OAM_DM_TYPE_tp_assign(*args)

def OFDPA_OAM_DM_TYPE_tp_value(*args):
  """OFDPA_OAM_DM_TYPE_tp_value(OFDPA_OAM_DM_TYPE_t * obj) -> OFDPA_OAM_DM_TYPE_t"""
  return _OFDPA_python.OFDPA_OAM_DM_TYPE_tp_value(*args)

def new_OFDPA_MLP_ROLE_tp():
  """new_OFDPA_MLP_ROLE_tp() -> OFDPA_MLP_ROLE_t *"""
  return _OFDPA_python.new_OFDPA_MLP_ROLE_tp()

def copy_OFDPA_MLP_ROLE_tp(*args):
  """copy_OFDPA_MLP_ROLE_tp(OFDPA_MLP_ROLE_t value) -> OFDPA_MLP_ROLE_t *"""
  return _OFDPA_python.copy_OFDPA_MLP_ROLE_tp(*args)

def delete_OFDPA_MLP_ROLE_tp(*args):
  """delete_OFDPA_MLP_ROLE_tp(OFDPA_MLP_ROLE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_MLP_ROLE_tp(*args)

def OFDPA_MLP_ROLE_tp_assign(*args):
  """OFDPA_MLP_ROLE_tp_assign(OFDPA_MLP_ROLE_t * obj, OFDPA_MLP_ROLE_t value)"""
  return _OFDPA_python.OFDPA_MLP_ROLE_tp_assign(*args)

def OFDPA_MLP_ROLE_tp_value(*args):
  """OFDPA_MLP_ROLE_tp_value(OFDPA_MLP_ROLE_t * obj) -> OFDPA_MLP_ROLE_t"""
  return _OFDPA_python.OFDPA_MLP_ROLE_tp_value(*args)

def new_OFDPA_OAM_LB_TEST_TLV_TYPE_tp():
  """new_OFDPA_OAM_LB_TEST_TLV_TYPE_tp() -> OFDPA_OAM_LB_TEST_TLV_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_OAM_LB_TEST_TLV_TYPE_tp()

def copy_OFDPA_OAM_LB_TEST_TLV_TYPE_tp(*args):
  """copy_OFDPA_OAM_LB_TEST_TLV_TYPE_tp(OFDPA_OAM_LB_TEST_TLV_TYPE_t value) -> OFDPA_OAM_LB_TEST_TLV_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_LB_TEST_TLV_TYPE_tp(*args)

def delete_OFDPA_OAM_LB_TEST_TLV_TYPE_tp(*args):
  """delete_OFDPA_OAM_LB_TEST_TLV_TYPE_tp(OFDPA_OAM_LB_TEST_TLV_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_LB_TEST_TLV_TYPE_tp(*args)

def OFDPA_OAM_LB_TEST_TLV_TYPE_tp_assign(*args):
  """OFDPA_OAM_LB_TEST_TLV_TYPE_tp_assign(OFDPA_OAM_LB_TEST_TLV_TYPE_t * obj, OFDPA_OAM_LB_TEST_TLV_TYPE_t value)"""
  return _OFDPA_python.OFDPA_OAM_LB_TEST_TLV_TYPE_tp_assign(*args)

def OFDPA_OAM_LB_TEST_TLV_TYPE_tp_value(*args):
  """OFDPA_OAM_LB_TEST_TLV_TYPE_tp_value(OFDPA_OAM_LB_TEST_TLV_TYPE_t * obj) -> OFDPA_OAM_LB_TEST_TLV_TYPE_t"""
  return _OFDPA_python.OFDPA_OAM_LB_TEST_TLV_TYPE_tp_value(*args)

def new_OFDPA_OAM_LB_DISCOVERY_TYPE_tp():
  """new_OFDPA_OAM_LB_DISCOVERY_TYPE_tp() -> OFDPA_OAM_LB_DISCOVERY_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_OAM_LB_DISCOVERY_TYPE_tp()

def copy_OFDPA_OAM_LB_DISCOVERY_TYPE_tp(*args):
  """copy_OFDPA_OAM_LB_DISCOVERY_TYPE_tp(OFDPA_OAM_LB_DISCOVERY_TYPE_t value) -> OFDPA_OAM_LB_DISCOVERY_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_LB_DISCOVERY_TYPE_tp(*args)

def delete_OFDPA_OAM_LB_DISCOVERY_TYPE_tp(*args):
  """delete_OFDPA_OAM_LB_DISCOVERY_TYPE_tp(OFDPA_OAM_LB_DISCOVERY_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_LB_DISCOVERY_TYPE_tp(*args)

def OFDPA_OAM_LB_DISCOVERY_TYPE_tp_assign(*args):
  """OFDPA_OAM_LB_DISCOVERY_TYPE_tp_assign(OFDPA_OAM_LB_DISCOVERY_TYPE_t * obj, OFDPA_OAM_LB_DISCOVERY_TYPE_t value)"""
  return _OFDPA_python.OFDPA_OAM_LB_DISCOVERY_TYPE_tp_assign(*args)

def OFDPA_OAM_LB_DISCOVERY_TYPE_tp_value(*args):
  """OFDPA_OAM_LB_DISCOVERY_TYPE_tp_value(OFDPA_OAM_LB_DISCOVERY_TYPE_t * obj) -> OFDPA_OAM_LB_DISCOVERY_TYPE_t"""
  return _OFDPA_python.OFDPA_OAM_LB_DISCOVERY_TYPE_tp_value(*args)

def new_OFDPA_OAM_RMEP_STATE_tp():
  """new_OFDPA_OAM_RMEP_STATE_tp() -> OFDPA_OAM_RMEP_STATE_t *"""
  return _OFDPA_python.new_OFDPA_OAM_RMEP_STATE_tp()

def copy_OFDPA_OAM_RMEP_STATE_tp(*args):
  """copy_OFDPA_OAM_RMEP_STATE_tp(OFDPA_OAM_RMEP_STATE_t value) -> OFDPA_OAM_RMEP_STATE_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_RMEP_STATE_tp(*args)

def delete_OFDPA_OAM_RMEP_STATE_tp(*args):
  """delete_OFDPA_OAM_RMEP_STATE_tp(OFDPA_OAM_RMEP_STATE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_RMEP_STATE_tp(*args)

def OFDPA_OAM_RMEP_STATE_tp_assign(*args):
  """OFDPA_OAM_RMEP_STATE_tp_assign(OFDPA_OAM_RMEP_STATE_t * obj, OFDPA_OAM_RMEP_STATE_t value)"""
  return _OFDPA_python.OFDPA_OAM_RMEP_STATE_tp_assign(*args)

def OFDPA_OAM_RMEP_STATE_tp_value(*args):
  """OFDPA_OAM_RMEP_STATE_tp_value(OFDPA_OAM_RMEP_STATE_t * obj) -> OFDPA_OAM_RMEP_STATE_t"""
  return _OFDPA_python.OFDPA_OAM_RMEP_STATE_tp_value(*args)

def new_OFDPA_OAM_BIN_MODE_tp():
  """new_OFDPA_OAM_BIN_MODE_tp() -> OFDPA_OAM_BIN_MODE_t *"""
  return _OFDPA_python.new_OFDPA_OAM_BIN_MODE_tp()

def copy_OFDPA_OAM_BIN_MODE_tp(*args):
  """copy_OFDPA_OAM_BIN_MODE_tp(OFDPA_OAM_BIN_MODE_t value) -> OFDPA_OAM_BIN_MODE_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_BIN_MODE_tp(*args)

def delete_OFDPA_OAM_BIN_MODE_tp(*args):
  """delete_OFDPA_OAM_BIN_MODE_tp(OFDPA_OAM_BIN_MODE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_BIN_MODE_tp(*args)

def OFDPA_OAM_BIN_MODE_tp_assign(*args):
  """OFDPA_OAM_BIN_MODE_tp_assign(OFDPA_OAM_BIN_MODE_t * obj, OFDPA_OAM_BIN_MODE_t value)"""
  return _OFDPA_python.OFDPA_OAM_BIN_MODE_tp_assign(*args)

def OFDPA_OAM_BIN_MODE_tp_value(*args):
  """OFDPA_OAM_BIN_MODE_tp_value(OFDPA_OAM_BIN_MODE_t * obj) -> OFDPA_OAM_BIN_MODE_t"""
  return _OFDPA_python.OFDPA_OAM_BIN_MODE_tp_value(*args)

def new_OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp():
  """new_OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp() -> OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_t *"""
  return _OFDPA_python.new_OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp()

def copy_OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp(*args):
  """copy_OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp(OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_t value) -> OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_t *"""
  return _OFDPA_python.copy_OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp(*args)

def delete_OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp(*args):
  """delete_OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp(OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_t * obj)"""
  return _OFDPA_python.delete_OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp(*args)

def OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp_assign(*args):
  """OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp_assign(OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_t * obj, OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_t value)"""
  return _OFDPA_python.OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp_assign(*args)

def OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp_value(*args):
  """OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp_value(OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_t * obj) -> OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_t"""
  return _OFDPA_python.OFDPA_PROTECTION_SWITCH_REQUEST_TYPE_tp_value(*args)

def new_OFDPA_MLP_ARCH_tp():
  """new_OFDPA_MLP_ARCH_tp() -> OFDPA_MLP_ARCH_t *"""
  return _OFDPA_python.new_OFDPA_MLP_ARCH_tp()

def copy_OFDPA_MLP_ARCH_tp(*args):
  """copy_OFDPA_MLP_ARCH_tp(OFDPA_MLP_ARCH_t value) -> OFDPA_MLP_ARCH_t *"""
  return _OFDPA_python.copy_OFDPA_MLP_ARCH_tp(*args)

def delete_OFDPA_MLP_ARCH_tp(*args):
  """delete_OFDPA_MLP_ARCH_tp(OFDPA_MLP_ARCH_t * obj)"""
  return _OFDPA_python.delete_OFDPA_MLP_ARCH_tp(*args)

def OFDPA_MLP_ARCH_tp_assign(*args):
  """OFDPA_MLP_ARCH_tp_assign(OFDPA_MLP_ARCH_t * obj, OFDPA_MLP_ARCH_t value)"""
  return _OFDPA_python.OFDPA_MLP_ARCH_tp_assign(*args)

def OFDPA_MLP_ARCH_tp_value(*args):
  """OFDPA_MLP_ARCH_tp_value(OFDPA_MLP_ARCH_t * obj) -> OFDPA_MLP_ARCH_t"""
  return _OFDPA_python.OFDPA_MLP_ARCH_tp_value(*args)

def new_OFDPA_OAM_EVENT_MASK_tp():
  """new_OFDPA_OAM_EVENT_MASK_tp() -> OFDPA_OAM_EVENT_MASK_t *"""
  return _OFDPA_python.new_OFDPA_OAM_EVENT_MASK_tp()

def copy_OFDPA_OAM_EVENT_MASK_tp(*args):
  """copy_OFDPA_OAM_EVENT_MASK_tp(OFDPA_OAM_EVENT_MASK_t value) -> OFDPA_OAM_EVENT_MASK_t *"""
  return _OFDPA_python.copy_OFDPA_OAM_EVENT_MASK_tp(*args)

def delete_OFDPA_OAM_EVENT_MASK_tp(*args):
  """delete_OFDPA_OAM_EVENT_MASK_tp(OFDPA_OAM_EVENT_MASK_t * obj)"""
  return _OFDPA_python.delete_OFDPA_OAM_EVENT_MASK_tp(*args)

def OFDPA_OAM_EVENT_MASK_tp_assign(*args):
  """OFDPA_OAM_EVENT_MASK_tp_assign(OFDPA_OAM_EVENT_MASK_t * obj, OFDPA_OAM_EVENT_MASK_t value)"""
  return _OFDPA_python.OFDPA_OAM_EVENT_MASK_tp_assign(*args)

def OFDPA_OAM_EVENT_MASK_tp_value(*args):
  """OFDPA_OAM_EVENT_MASK_tp_value(OFDPA_OAM_EVENT_MASK_t * obj) -> OFDPA_OAM_EVENT_MASK_t"""
  return _OFDPA_python.OFDPA_OAM_EVENT_MASK_tp_value(*args)
# This file is compatible with both classic and new-style classes.


