|
def | getSortKey (self) |
|
def | getPath (self) |
|
def | setPath (self, n, decode_path=False) |
|
def | getUnsignedData (self, num) |
|
def | getData (self, num) |
|
def | setUnsignedData (self, num, val) |
|
def | setData (self, num, val) |
|
def | getName (self) |
|
def | setName (self, n) |
|
def | setUserAgent (self, uA) |
|
def | getUserAgent (self) |
|
def | setTransportHeaders (self, headers) |
|
def | getTransportHeaders (self) |
|
def | getSuburi (self) |
|
def | setSuburi (self, sU) |
|
def | __init__ (self, *args) |
|
def | toString (self) |
|
def | toCompareString (self) |
|
def | __eq__ (self, c) |
|
def | __ne__ (self, c) |
|
def | __lt__ (self, c) |
|
def | valid (self) |
|
def | compare (self, ref) |
|
def | hash (self) |
|
◆ __init__()
def enigma.eServiceReference.__init__ |
( |
|
self, |
|
|
* |
args |
|
) |
| |
__init__(eServiceReference self) -> eServiceReference
__init__(eServiceReference self, int type, int flags, std::string const & p) -> eServiceReference
__init__(eServiceReference self, std::string const & string) -> eServiceReference
◆ __eq__()
def enigma.eServiceReference.__eq__ |
( |
|
self, |
|
|
|
c |
|
) |
| |
__eq__(eServiceReference self, eServiceReference c) -> bool
◆ __lt__()
def enigma.eServiceReference.__lt__ |
( |
|
self, |
|
|
|
c |
|
) |
| |
__lt__(eServiceReference self, eServiceReference c) -> bool
◆ __ne__()
def enigma.eServiceReference.__ne__ |
( |
|
self, |
|
|
|
c |
|
) |
| |
__ne__(eServiceReference self, eServiceReference c) -> bool
◆ compare()
def enigma.eServiceReference.compare |
( |
|
self, |
|
|
|
ref |
|
) |
| |
compare(eServiceReference self, eServiceReference ref) -> int
◆ getData()
def enigma.eServiceReference.getData |
( |
|
self, |
|
|
|
num |
|
) |
| |
getData(eServiceReference self, unsigned int num) -> int
◆ getName()
def enigma.eServiceReference.getName |
( |
|
self | ) |
|
getName(eServiceReference self) -> std::string
◆ getPath()
def enigma.eServiceReference.getPath |
( |
|
self | ) |
|
◆ getSortKey()
def enigma.eServiceReference.getSortKey |
( |
|
self | ) |
|
getSortKey(eServiceReference self) -> int
◆ getSuburi()
def enigma.eServiceReference.getSuburi |
( |
|
self | ) |
|
getSuburi(eServiceReference self) -> std::string
◆ getTransportHeaders()
def enigma.eServiceReference.getTransportHeaders |
( |
|
self | ) |
|
getTransportHeaders(eServiceReference self) -> StringMap
◆ getUnsignedData()
def enigma.eServiceReference.getUnsignedData |
( |
|
self, |
|
|
|
num |
|
) |
| |
getUnsignedData(eServiceReference self, unsigned int num) -> unsigned int
◆ getUserAgent()
def enigma.eServiceReference.getUserAgent |
( |
|
self | ) |
|
getUserAgent(eServiceReference self) -> std::string const
◆ hash()
def enigma.eServiceReference.hash |
( |
|
self | ) |
|
hash(eServiceReference self) -> long
◆ setData()
def enigma.eServiceReference.setData |
( |
|
self, |
|
|
|
num, |
|
|
|
val |
|
) |
| |
setData(eServiceReference self, unsigned int num, int val)
◆ setName()
def enigma.eServiceReference.setName |
( |
|
self, |
|
|
|
n |
|
) |
| |
setName(eServiceReference self, std::string const & n)
◆ setPath()
def enigma.eServiceReference.setPath |
( |
|
self, |
|
|
|
n, |
|
|
|
decode_path = False |
|
) |
| |
setPath(eServiceReference self, std::string const & n, bool decode_path=False)
setPath(eServiceReference self, std::string const & n)
◆ setSuburi()
def enigma.eServiceReference.setSuburi |
( |
|
self, |
|
|
|
sU |
|
) |
| |
setSuburi(eServiceReference self, std::string const & sU)
◆ setTransportHeaders()
def enigma.eServiceReference.setTransportHeaders |
( |
|
self, |
|
|
|
headers |
|
) |
| |
setTransportHeaders(eServiceReference self, StringMap headers)
◆ setUnsignedData()
def enigma.eServiceReference.setUnsignedData |
( |
|
self, |
|
|
|
num, |
|
|
|
val |
|
) |
| |
setUnsignedData(eServiceReference self, unsigned int num, unsigned int val)
◆ setUserAgent()
def enigma.eServiceReference.setUserAgent |
( |
|
self, |
|
|
|
uA |
|
) |
| |
setUserAgent(eServiceReference self, std::string const & uA)
◆ toCompareString()
def enigma.eServiceReference.toCompareString |
( |
|
self | ) |
|
toCompareString(eServiceReference self) -> std::string
◆ toString()
def enigma.eServiceReference.toString |
( |
|
self | ) |
|
toString(eServiceReference self) -> std::string
◆ valid()
def enigma.eServiceReference.valid |
( |
|
self | ) |
|
valid(eServiceReference self) -> int
◆ canDescent
enigma.eServiceReference.canDescent = _enigma.eServiceReference_canDescent |
|
static |
◆ compare
enigma.eServiceReference.compare |
|
static |
◆ flagDirectory
enigma.eServiceReference.flagDirectory = _enigma.eServiceReference_flagDirectory |
|
static |
◆ flags
enigma.eServiceReference.flags = _swig_property(_enigma.eServiceReference_flags_get, _enigma.eServiceReference_flags_set) |
|
static |
◆ getData
enigma.eServiceReference.getData |
|
static |
◆ getName
enigma.eServiceReference.getName |
|
static |
◆ getPath
enigma.eServiceReference.getPath |
|
static |
◆ getSortKey
enigma.eServiceReference.getSortKey |
|
static |
◆ getSuburi
enigma.eServiceReference.getSuburi |
|
static |
◆ getTransportHeaders
enigma.eServiceReference.getTransportHeaders |
|
static |
◆ getUnsignedData
enigma.eServiceReference.getUnsignedData |
|
static |
◆ getUserAgent
enigma.eServiceReference.getUserAgent |
|
static |
◆ hash
enigma.eServiceReference.hash |
|
static |
◆ hasSortKey
enigma.eServiceReference.hasSortKey = _enigma.eServiceReference_hasSortKey |
|
static |
◆ idDB
enigma.eServiceReference.idDB = _enigma.eServiceReference_idDB |
|
static |
◆ idDVB
enigma.eServiceReference.idDVB = _enigma.eServiceReference_idDVB |
|
static |
◆ idDVD
enigma.eServiceReference.idDVD = _enigma.eServiceReference_idDVD |
|
static |
◆ idFile
enigma.eServiceReference.idFile = _enigma.eServiceReference_idFile |
|
static |
◆ idGST
enigma.eServiceReference.idGST = _enigma.eServiceReference_idGST |
|
static |
◆ idInvalid
enigma.eServiceReference.idInvalid = _enigma.eServiceReference_idInvalid |
|
static |
◆ idM2TS
enigma.eServiceReference.idM2TS = _enigma.eServiceReference_idM2TS |
|
static |
◆ idStream
enigma.eServiceReference.idStream = _enigma.eServiceReference_idStream |
|
static |
◆ idStructure
enigma.eServiceReference.idStructure = _enigma.eServiceReference_idStructure |
|
static |
◆ idURI
enigma.eServiceReference.idURI = _enigma.eServiceReference_idURI |
|
static |
◆ idUser
enigma.eServiceReference.idUser = _enigma.eServiceReference_idUser |
|
static |
◆ isDirectory
enigma.eServiceReference.isDirectory = _enigma.eServiceReference_isDirectory |
|
static |
◆ isGroup
enigma.eServiceReference.isGroup = _enigma.eServiceReference_isGroup |
|
static |
◆ isLive
enigma.eServiceReference.isLive = _enigma.eServiceReference_isLive |
|
static |
◆ isMarker
enigma.eServiceReference.isMarker = _enigma.eServiceReference_isMarker |
|
static |
◆ isMulticast
enigma.eServiceReference.isMulticast = _enigma.eServiceReference_isMulticast |
|
static |
◆ mustDescent
enigma.eServiceReference.mustDescent = _enigma.eServiceReference_mustDescent |
|
static |
◆ mustJoinMulticastGroup
enigma.eServiceReference.mustJoinMulticastGroup = _enigma.eServiceReference_mustJoinMulticastGroup |
|
static |
◆ setData
enigma.eServiceReference.setData |
|
static |
◆ setName
enigma.eServiceReference.setName |
|
static |
◆ setPath
enigma.eServiceReference.setPath |
|
static |
◆ setSuburi
enigma.eServiceReference.setSuburi |
|
static |
◆ setTransportHeaders
enigma.eServiceReference.setTransportHeaders |
|
static |
◆ setUnsignedData
enigma.eServiceReference.setUnsignedData |
|
static |
◆ setUserAgent
enigma.eServiceReference.setUserAgent |
|
static |
◆ shouldSort
enigma.eServiceReference.shouldSort = _enigma.eServiceReference_shouldSort |
|
static |
◆ sort1
enigma.eServiceReference.sort1 = _enigma.eServiceReference_sort1 |
|
static |
◆ thisown
enigma.eServiceReference.thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag') |
|
static |
◆ toCompareString
enigma.eServiceReference.toCompareString |
|
static |
◆ toString
enigma.eServiceReference.toString |
|
static |
◆ type
enigma.eServiceReference.type = _swig_property(_enigma.eServiceReference_type_get, _enigma.eServiceReference_type_set) |
|
static |
◆ valid
enigma.eServiceReference.valid |
|
static |
The documentation for this class was generated from the following file: