The list of all ports belonging to this component.
545710
def ports(self):
        ''''''
        with self._mutex:
            if not self._ports:
                self._ports = [ports.parse_port(port, self) \
                               for port in self._obj.get_ports()]
        return self._ports
1173677
function gotList(thelist) {
  println("List of Serial Ports:");
  // theList is an array of their names
  for (var i = 0; i < thelist.length; i++) {
    // Display in the console
    println(i + " " + thelist[i]);
  }
}
311263
public static Collection<Component> getComponentsList() {
    TransactionLogger instance = getInstance();
    if (instance == null) {
      return null;
    }

    return instance.components.values();
  }
874246
def ports_as_list(port_str):
    
    if not port_str:
        LOGGER.info("Invalid port value")
        return [None, None]

    if ports_str_check_failed(port_str):
        LOGGER.info("{0}: Port list malformed.")
        return [None, None]

    tcp_list = list()
    udp_list = list()
    ports = port_str.replace(' ', '')
    b_tcp = ports.find("T")
    b_udp = ports.find("U")

    if ports[b_tcp - 1] == ',':
        ports = ports[:b_tcp - 1] + ports[b_tcp:]
    if ports[b_udp - 1] == ',':
        ports = ports[:b_udp - 1] + ports[b_udp:]
    ports = port_str_arrange(ports)

    tports = ''
    uports = ''
    # TCP ports listed first, then UDP ports
    if b_udp != -1 and b_tcp != -1:
        tports = ports[ports.index('T:') + 2:ports.index('U:')]
        uports = ports[ports.index('U:') + 2:]
    # Only UDP ports
    elif b_tcp == -1 and b_udp != -1:
        uports = ports[ports.index('U:') + 2:]
    # Only TCP ports
    elif b_udp == -1 and b_tcp != -1:
        tports = ports[ports.index('T:') + 2:]
    else:
        tports = ports

    if tports:
        for port in tports.split(','):
            if '-' in port:
                tcp_list.extend(port_range_expand(port))
            else:
                tcp_list.append(int(port))
        tcp_list.sort()
    if uports:
        for port in uports.split(','):
            if '-' in port:
                udp_list.extend(port_range_expand(port))
            else:
                udp_list.append(int(port))
        udp_list.sort()

    return (tcp_list, udp_list)
873443
def component_list(self):
	
		
		
		comp_list = []
		self.__component_list(self.component(None), comp_list)
		return sorted(comp_list)
40447
def getPorts(self):
        """"""
        if self.ports: # no need to get ports if ports are al
            return self.ports
        if not self._gotPorts:
            self.ports = [
                portpicker.pick_unused_port(), # game_port
                portpicker.pick_unused_port(), # base_port
                portpicker.pick_unused_port(), # shared_port / init port
            ]
            self._gotPorts = True
        return self.ports
762395
def _extract_ports(port_string):
    
    _ports = str(port_string)
    if '-' in _ports:
        start, end = _ports.split('-')
        return {'min_port': start, 'max_port': end}
    return {'min_port': _ports, 'max_port': _ports}
1263347
public List<PortletType<PortletDescriptor>> getAllPortlet()
   {
      List<PortletType<PortletDescriptor>> list = new ArrayList<PortletType<PortletDescriptor>>();
      List<Node> nodeList = model.get("portlet");
      for(Node node: nodeList)
      {
         PortletType<PortletDescriptor>  type = new PortletTypeImpl<PortletDescriptor>(this, "portlet", model, node);
         list.add(type);
      }
      return list;
   }
785906
def available_ports(self):
        
        from mbuild.port import Port
        return [port for port in self.labels.values()
                if isinstance(port, Port) and not port.used]
932302
def port(self):
        
        return self._val.port or DEFAULT_PORTS.get(self._val.scheme)
170711
def source_ports(self):
        
        start_port = self.blacklist.get('BlacklistEntrySourcePort')
        if start_port is not None:
            return '{}-{}'.format(
                start_port, self.blacklist.get('BlacklistEntrySourcePortRange'))
        return 'ANY'
1273782
def p_portlist_empty(self, p):
        ''
        p[0] = Portlist(ports=(), lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
289379
public List<CustomPortletModeType<PortletDescriptor>> getAllCustomPortletMode()
   {
      List<CustomPortletModeType<PortletDescriptor>> list = new ArrayList<CustomPortletModeType<PortletDescriptor>>();
      List<Node> nodeList = model.get("custom-portlet-mode");
      for(Node node: nodeList)
      {
         CustomPortletModeType<PortletDescriptor>  type = new CustomPortletModeTypeImpl<PortletDescriptor>(this, "custom-portlet-mode", model, node);
         list.add(type);
      }
      return list;
   }
176312
def p_instance_ports_list(self, p):
        ''
        p[0] = p[1] + (p[3],)
        p.set_lineno(0, p.lineno(1))
114740
def _get_switchports(profile):
        """"""
        switchports = []
        if profile.get('local_link_information'):
            for link in profile['local_link_information']:
                if 'switch_info' in link and 'port_id' in link:
                    switch = link['switch_info']
                    interface = link['port_id']
                    switchports.append((switch, interface))
                else:
                    LOG.warning("Incomplete link information: %s", link)
        return switchports
209930
def ports(self):
        
        # We do here some lazy loading.
        if not self._ports:
            family = self.get_property('adapter-family')
            try:
                port_type = self.port_type_by_family[family]
            except KeyError:
                port_type = None
            self._ports = PortManager(self, port_type)
        return self._ports
1035205
public List<CustomWindowStateType<PortletDescriptor>> getAllCustomWindowState()
   {
      List<CustomWindowStateType<PortletDescriptor>> list = new ArrayList<CustomWindowStateType<PortletDescriptor>>();
      List<Node> nodeList = model.get("custom-window-state");
      for(Node node: nodeList)
      {
         CustomWindowStateType<PortletDescriptor>  type = new CustomWindowStateTypeImpl<PortletDescriptor>(this, "custom-window-state", model, node);
         list.add(type);
      }
      return list;
   }