Gets all component references registered in this reference map.

        :return: a list with component references.
334446
def get_all(self):
        
        components = []
        
        self._lock.acquire()
        try:
            for reference in self._references:
                components.append(reference.get_component())
        finally:
            self._lock.release()

        return components
728838
def selectedIndexes(self):
        """"""
        model = self.model()
        indexes = []
        for comp in self._selectedComponents:
            index = model.indexByComponent(comp)
            if index is None:
                # must have been removed from model, discard
                self._selectedComponents.remove(comp)
            else:
                indexes.append(index)
        return indexes
873443
def component_list(self):
	
		
		
		comp_list = []
		self.__component_list(self.component(None), comp_list)
		return sorted(comp_list)
456251
def get_entities_by_components(self, *components):
        '''
        
        '''
        return list(filter(lambda entity:
                           set(components) <=
                           set(map(type, entity.get_components())),
                           self._entities))
299057
def tissues_in_references(self):
        
        return [x[0] for x in self.session.query(models.TissueInReference.tissue).all()]
553162
def getall(self):
        

        vrrps = dict()

        # Find the available interfaces
        interfaces = re.findall(r'^interface\s(\S+)', self.config, re.M)

        # Get the vrrps defined for each interface
        for interface in interfaces:
            vrrp = self.get(interface)
            # Only add those interfaces that have vrrps defined
            if vrrp:
                vrrps.update({interface: vrrp})

        return vrrps
655574
def references(self):
    '''
    
    '''

    if not getattr(self, '_references', False):
      def add_protocol(url):
        return url if url.startswith('http') else 'http:' + url

      self._references = [
        add_protocol(link['*'])
        for link in self.__continued_query({
          'prop': 'extlinks',
          'ellimit': 'max'
        })
      ]

    return self._references
238201
private ArrayList<ResourceRequirement> getSortedRAMComponents(Set<String> componentNames) {
    ArrayList<ResourceRequirement> resourceRequirements = new ArrayList<>();
    Map<String, ByteAmount> ramMap = TopologyUtils.getComponentRamMapConfig(topology);

    for (String componentName : componentNames) {
      resourceRequirements.add(new ResourceRequirement(componentName,
          ramMap.getOrDefault(componentName, ByteAmount.ZERO)));
    }
    Collections.sort(resourceRequirements, SortingStrategy.RAM_FIRST.reversed());
    return resourceRequirements;
  }
536536
def reference(self):
        
        ref = ModelReference()
        ref._proto = self._proto.model_reference
        return ref
1055984
def referenced_vertices(self):
        
        referenced = np.zeros(len(self.vertices), dtype=np.bool)
        referenced[self.faces] = True
        return referenced
74897
private function getComponents()
    {
        // Order of components being registered is extremely important!
        return array(
            new Component\Request(),
            new Component\Paginator(),
            new Component\Db(),
            new Component\MapperFactory(),
            new Component\SessionBag(),
            new Component\AuthManager(),
            new Component\AuthAttemptLimit(),
            new Component\ParamBag(),
            new Component\AppConfig(),
            new Component\Config(),
            new Component\ModuleManager(),
            new Component\Translator(),
            new Component\Response(),
            new Component\FlashBag(),
            new Component\FormAttribute(),
            new Component\ValidatorFactory(),
            new Component\WidgetFactory(),
            new Component\UrlBuilder(),
            new Component\View(),
            new Component\Profiler(),
            new Component\Cache(),
            new Component\CsrfProtector(),
            new Component\Captcha(),
            // Dispatcher always must be very last component to be registered
            new Component\Dispatcher()
        );
    }
311263
public static Collection<Component> getComponentsList() {
    TransactionLogger instance = getInstance();
    if (instance == null) {
      return null;
    }

    return instance.components.values();
  }
1203341
def extensions(self, component):
        
        classes = ComponentMeta._registry.get(self.interface, ())
        components = [component.compmgr[cls] for cls in classes]
        return [c for c in components if c]
609315
private List<String> getImportComponents( Component component ) {

		List<String> result = new ArrayList<> ();
		Map<String,Boolean> map = ComponentHelpers.findComponentDependenciesFor( component );
		for( Map.Entry<String,Boolean> entry : map.entrySet()) {
			String s = applyLink( entry.getKey(), entry.getKey());
			s += entry.getValue() ? this.messages.get( "optional" ) : this.messages.get( "required" ); //$NON-NLS-1$ //$NON-NLS-2$
			result.add( s );
		}

		return result;
	}
1173688
def getrefs(self, reflist):
        
        alist = []
        for element in reflist:
            if element[0].upper() in self.dt:
                for elm in self.dt[element[0].upper()]:
                    alist.append(elm[element[1]])
        return alist
852854
def get_reference_results(self):
        
        referenceresults = self.context.getReferenceResults()
        return dict(map(lambda rr: (rr.get("uid"), rr), referenceresults))
651084
def get_panels(self):
        
        all_panels = []
        panel_groups = self.get_panel_groups()
        for panel_group in panel_groups.values():
            all_panels.extend(panel_group)
        return all_panels