Return the symbolic name for a CIM status code.
356276
def _statuscode2name(status_code):
    """"""
    try:
        s = _STATUSCODE2NAME[status_code]
    except KeyError:
        s = _format("Invalid status code {0}", status_code)
    return s
38096
def _get_reference(self):
        """"""
        sha, target_ref_path = self._get_ref_info(self.repo, self.path)
        if target_ref_path is None:
            raise TypeError("%s is a detached symbolic reference as it points to %r" % (self, sha))
        return self.from_path(self.repo, target_ref_path)
1072445
def name(self):
        
        ret = ctypes.c_char_p()
        success = ctypes.c_int()
        check_call(_LIB.MXSymbolGetName(
            self.handle, ctypes.byref(ret), ctypes.byref(success)))
        if success.value != 0:
            return py_str(ret.value)
        else:
            return None
733506
def display_name(self):
        """"""
        if self.name:
            return self.name
        elif self.canonical_alias:
            return self.canonical_alias

        # Member display names without me
        members = [u.get_display_name(self) for u in self.get_joined_members() if
                   self.client.user_id != u.user_id]
        members.sort()

        if len(members) == 1:
            return members[0]
        elif len(members) == 2:
            return "{0} and {1}".format(members[0], members[1])
        elif len(members) > 2:
            return "{0} and {1} others".format(members[0], len(members) - 1)
        else:  # len(members) <= 0 or not an integer
            # TODO i18n
            return "Empty room"
741704
def full_name(self):
        """"""
        if self.requested_version is not None:
            return '%s-%s' % (self.name, self.requested_version)
        return self.name
677612
def nodata(status_code):
    """"""
    lookup = {
        '1': 'No armored data.',
        '2': 'Expected a packet but did not find one.',
        '3': 'Invalid packet found, this may indicate a non OpenPGP message.',
        '4': 'Signature expected but not found.' }
    for key, value in lookup.items():
        if str(status_code) == key:
            return value
434279
def get_name(self):
        
        if self.name_idx_value == None:
            self.name_idx_value = self.CM.get_string(self.name_idx)

        return self.name_idx_value
151924
def _get_check_versioned_name(self, check_name):
        
        if ':' not in check_name or ':latest' in check_name:
            check_name = ':'.join((check_name.split(':')[0],
                                   self.checkers[check_name]._cc_spec_version))
        return check_name
176609
def get_name(self, origin=None):
        """"""

        token = self.get()
        if not token.is_identifier():
            raise dns.exception.SyntaxError('expecting an identifier')
        return dns.name.from_text(token.value, origin)
1062097
def status(self):
        """"""
        return {self._acronym_status(l): l for l in self.resp_text.split('\n')
                if l.startswith(self.prefix_status)}
212427
def get_name(self):
        
        if self.OP > 0xff:
            if self.OP >= 0xf2ff:
                return DALVIK_OPCODES_OPTIMIZED[self.OP][1][0]
            return DALVIK_OPCODES_EXTENDED_WIDTH[self.OP][1][0]
        return DALVIK_OPCODES_FORMAT[self.OP][1][0]
965403
def status(name, sig=None):
    '''
    
    '''
    cmd = 's6-svstat {0}'.format(_service_path(name))
    out = __salt__['cmd.run_stdout'](cmd)
    try:
        pid = re.search(r'up \(pid (\d+)\)', out).group(1)
    except AttributeError:
        pid = ''
    return pid
405491
def get_system_name(self, oid_system_name):
        """"""
        short_system_name = None

        if oid_system_name == '':
            return short_system_name

        # Find the short name in the oid_to_short_os_name dict
        for r, v in iteritems(oid_to_short_system_name):
            if re.search(r, oid_system_name):
                short_system_name = v
                break

        return short_system_name
768570
def get_sid_info(self,j):
        ''''''
        h = self.gdx_handle
        r, name, dims, stype = gdxcc.gdxSymbolInfo(h, j)
        assert r, '%d is not a valid symbol number' % j
        r, records, userinfo, description = gdxcc.gdxSymbolInfoX(h, j)
        assert r, '%d is not a valid symbol number' % j
        return {'name':name, 'stype':stype, 'desc':description, 'dim':dims}
1282930
def mangled_name(self):
        """"""
        if not hasattr(self, '_mangled_name'):
            self._mangled_name = conf.lib.clang_Cursor_getMangling(self)

        return self._mangled_name
1367074
def _lookup_symbols(self, symbols_filename):
        """"""
        symbol_lookup = GenewaysSymbols(symbols_filename)
        for action in self.actions:
            action.up_symbol = symbol_lookup.id_to_symbol(action.up)
            action.dn_symbol = symbol_lookup.id_to_symbol(action.dn)
227533
def sysname(self):
		

		pchar = self._libinput.libinput_device_get_sysname(self._handle)
		return string_at(pchar).decode()