Retrieves a description of the given catalog's system or user function parameters and return type.
349944
@Override
    public ResultSet getFunctionColumns(String catalog, String schemaPattern, String functionNamePattern, String columnNamePattern) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
18124
def description(self, platform, key):
        """"""
        patterns = self._dict_dscr.get(platform, None)
        description = patterns.get(key, None)
        return description
1281860
def systemInformationType9():
    """"""
    a = L2PseudoLength(l2pLength=0x01)
    b = TpPd(pd=0x6)
    c = MessageType(mesType=0x4)  # 00000100
    d = Si9RestOctets()
    packet = a / b / c / d
    return packet
444298
public CatalogueDescription discover( String uri, Parameter... parameters )
    {
        return invoke( descriptionDigesterLoader, uri, parameters );
    }
1203758
def get_system_info():
    '''
    
    '''
    def byte_calc(val):
        val = float(val)
        if val < 2**10:
            return '{0:.3f}B'.format(val)
        elif val < 2**20:
            return '{0:.3f}KB'.format(val / 2**10)
        elif val < 2**30:
            return '{0:.3f}MB'.format(val / 2**20)
        elif val < 2**40:
            return '{0:.3f}GB'.format(val / 2**30)
        else:
            return '{0:.3f}TB'.format(val / 2**40)

    # Lookup dicts for Win32_OperatingSystem
    os_type = {1: 'Work Station',
               2: 'Domain Controller',
               3: 'Server'}

    # lookup dicts for Win32_ComputerSystem
    domain_role = {0: 'Standalone Workstation',
                   1: 'Member Workstation',
                   2: 'Standalone Server',
                   3: 'Member Server',
                   4: 'Backup Domain Controller',
                   5: 'Primary Domain Controller'}
    warning_states = {1: 'Other',
                      2: 'Unknown',
                      3: 'Safe',
                      4: 'Warning',
                      5: 'Critical',
                      6: 'Non-recoverable'}
    pc_system_types = {0: 'Unspecified',
                       1: 'Desktop',
                       2: 'Mobile',
                       3: 'Workstation',
                       4: 'Enterprise Server',
                       5: 'SOHO Server',
                       6: 'Appliance PC',
                       7: 'Performance Server',
                       8: 'Maximum'}

    # Connect to WMI
    with salt.utils.winapi.Com():
        conn = wmi.WMI()

        system = conn.Win32_OperatingSystem()[0]
        ret = {'name': get_computer_name(),
               'description': system.Description,
               'install_date': system.InstallDate,
               'last_boot': system.LastBootUpTime,
               'os_manufacturer': system.Manufacturer,
               'os_name': system.Caption,
               'users': system.NumberOfUsers,
               'organization': system.Organization,
               'os_architecture': system.OSArchitecture,
               'primary': system.Primary,
               'os_type': os_type[system.ProductType],
               'registered_user': system.RegisteredUser,
               'system_directory': system.SystemDirectory,
               'system_drive': system.SystemDrive,
               'os_version': system.Version,
               'windows_directory': system.WindowsDirectory}

        system = conn.Win32_ComputerSystem()[0]
        # Get pc_system_type depending on Windows version
        if platform.release() in ['Vista', '7', '8']:
            # Types for Vista, 7, and 8
            pc_system_type = pc_system_types[system.PCSystemType]
        else:
            # New types were added with 8.1 and newer
            pc_system_types.update({8: 'Slate', 9: 'Maximum'})
            pc_system_type = pc_system_types[system.PCSystemType]
        ret.update({
            'bootup_state': system.BootupState,
            'caption': system.Caption,
            'chassis_bootup_state': warning_states[system.ChassisBootupState],
            'chassis_sku_number': system.ChassisSKUNumber,
            'dns_hostname': system.DNSHostname,
            'domain': system.Domain,
            'domain_role': domain_role[system.DomainRole],
            'hardware_manufacturer': system.Manufacturer,
            'hardware_model': system.Model,
            'network_server_mode_enabled': system.NetworkServerModeEnabled,
            'part_of_domain': system.PartOfDomain,
            'pc_system_type': pc_system_type,
            'power_state': system.PowerState,
            'status': system.Status,
            'system_type': system.SystemType,
            'total_physical_memory': byte_calc(system.TotalPhysicalMemory),
            'total_physical_memory_raw': system.TotalPhysicalMemory,
            'thermal_state': warning_states[system.ThermalState],
            'workgroup': system.Workgroup
        })
        # Get processor information
        processors = conn.Win32_Processor()
        ret['processors'] = 0
        ret['processors_logical'] = 0
        ret['processor_cores'] = 0
        ret['processor_cores_enabled'] = 0
        ret['processor_manufacturer'] = processors[0].Manufacturer
        ret['processor_max_clock_speed'] = six.text_type(processors[0].MaxClockSpeed) + 'MHz'
        for processor in processors:
            ret['processors'] += 1
            ret['processors_logical'] += processor.NumberOfLogicalProcessors
            ret['processor_cores'] += processor.NumberOfCores
            ret['processor_cores_enabled'] += processor.NumberOfEnabledCore

        bios = conn.Win32_BIOS()[0]
        ret.update({'hardware_serial': bios.SerialNumber,
                    'bios_manufacturer': bios.Manufacturer,
                    'bios_version': bios.Version,
                    'bios_details': bios.BIOSVersion,
                    'bios_caption': bios.Caption,
                    'bios_description': bios.Description})
        ret['install_date'] = _convert_date_time_string(ret['install_date'])
        ret['last_boot'] = _convert_date_time_string(ret['last_boot'])
    return ret
1051975
def _get_type(cls, ptr):
        """"""

        # fall back to the base class if unknown
        return cls.__types.get(lib.g_base_info_get_type(ptr), cls)
1364014
def describe(self):
        ''''''
        description = {
            'description': self._description,
            'type': self.name,
        }
        description.update(self.extra_params)
        return description
876539
def get_sort_spec(self):
        
        all_indexes = self.catalog.get_indexes()
        si = req.get_sort_on(allowed_indexes=all_indexes)
        so = req.get_sort_order()
        return si, so
1310696
def endpoint_catalog(catalog=None):  # noqa: E501
    
    if connexion.request.is_json:
        catalog = UserAuth.from_dict(connexion.request.get_json())  # noqa: E501
    return 'do some magic!'
1297429
function documentParam(param, paramDictionary, procedureOrService) {
    let typeString = getTypeStringFromCode(param.type, null, param);
    let name = getParamName(param);
    let options = {
        type: param.type,
        paramDictionary: paramDictionary,
        paramName: name
    };
    let description = getParamDescription(options);
    if (description !== '') {
        return ' * @param ' + typeString + ' ' + name + ' - ' + description;
    }
    return ' * @param ' + typeString + ' ' + name;
}
47662
def get_type(cls, result_name):
        
        if result_name == "Alarm":
            return cls.ALARM
        elif result_name == "Log Message":
            return cls.LOG
        elif result_name == "Error Message":
            return cls.ERROR
        elif result_name == "Host Detail":
            return cls.HOST_DETAIL
        else:
            assert False, "Erroneous result name {0}.".format(result_name)
49704
def getCatalogDefinitions():
    
    final = {}
    analysis_request = bika_catalog_analysisrequest_listing_definition
    analysis = bika_catalog_analysis_listing_definition
    autoimportlogs = bika_catalog_autoimportlogs_listing_definition
    worksheet = bika_catalog_worksheet_listing_definition
    report = bika_catalog_report_definition
    # Merging the catalogs
    final.update(analysis_request)
    final.update(analysis)
    final.update(autoimportlogs)
    final.update(worksheet)
    final.update(report)
    return final
6601
@SuppressWarnings("unchecked")
	public <T extends EntitySystem> T getSystem(Class<T> systemType) {
		return systemManager.getSystem(systemType);
	}
438449
def get_type_data(name):
    
    name = name.upper()
    try:
        return {
            'authority': 'birdland.mit.edu',
            'namespace': 'unit system',
            'identifier': name,
            'domain': 'Unit System Types',
            'display_name': JEFFS_UNIT_SYSTEM_TYPES[name] + ' Unit System Type',
            'display_label': JEFFS_UNIT_SYSTEM_TYPES[name],
            'description': ('The unit system type for the ' +
                            JEFFS_UNIT_SYSTEM_TYPES[name] + ' System')
        }
    except KeyError:
        raise NotFound('Unit System Type: ' + name)
374788
def get_scanner_param_type(self, param):
        
        assert isinstance(param, str)
        entry = self.scanner_params.get(param)
        if not entry:
            return None
        return entry.get('type')
432505
def GetMetricTypes(self, request, context):
        """"""
        LOG.debug("GetMetricTypes called")
        try:
            metrics = self.plugin.update_catalog(ConfigMap(pb=request.config))
            return MetricsReply(metrics=[m.pb for m in metrics])
        except Exception as err:
            msg = "message: {}\n\nstack trace: {}".format(
                err, traceback.format_exc())
            return MetricsReply(metrics=[], error=msg)
265567
def _get_item_class(self, url):
        
        if '/layers/' in url:
            return Layer
        elif '/tables/' in url:
            return Table
        elif '/sets/' in url:
            return Set
        # elif '/documents/' in url:
        #     return Document
        else:
            raise NotImplementedError("No support for catalog results of type %s" % url)