Returns the external references of the element
        @rtype: L{CexternalReference}
        @return: the external references (iterator)
506452
def get_external_references(self):
        
        node = self.node.find('externalReferences')
        if node is not None:
            ext_refs = CexternalReferences(node)
            for ext_ref in ext_refs:
                yield ext_ref
716537
def _get_reference(self):
        
        super()._get_reference()
        self.cube_body_id = self.sim.model.body_name2id("cube")
        self.l_finger_geom_ids = [
            self.sim.model.geom_name2id(x) for x in self.gripper.left_finger_geoms
        ]
        self.r_finger_geom_ids = [
            self.sim.model.geom_name2id(x) for x in self.gripper.right_finger_geoms
        ]
        self.cube_geom_id = self.sim.model.geom_name2id("cube")
287810
def references_by_element(self, element_href):
        
        result = self.make_request(
            method='create',
            resource='references_by_element',
            json={
                'value': element_href})
        return result
4234
def remove_external_references(self):
        
        for ex_ref_node in self.node.findall('externalReferences'):
            self.node.remove(ex_ref_node)
1303451
def all_children(flag=nil)
		also_foreign = (flag==:also_foreign)
		arr = []
		ecore = self.class.ecore
		# Awful hack to forbid the same reference is visited twice when
		# two references with the same name are found
		already_used_references = []
		ecore.eAllReferences.sort_by{|r| r.name}.select {|r| r.containment}.each do |ref|
			unless already_used_references.include?(ref.name)
				res = self.send(ref.name.to_sym)
				if ref.many
					d = arr.count
					res.each do |el|
						arr << el unless res==nil
					end
				elsif res!=nil
					d = arr.count
					arr << res
				end
				already_used_references << ref.name
			end
		end
		if also_foreign
			arr.concat(self.foreign_asts)
		end
		arr
	end
98707
def remote_references(self):
        
        return ReferencesDataFrame(self._engine_dataframe.getRemoteReferences(),
                                   self._session, self._implicits)
1151779
public ServiceReference<T> getHighestRankedReference() {
        Iterator<ConcurrentServiceReferenceElement<T>> iterator = elementSet.iterator();
        return iterator.hasNext() ? iterator.next().getReference() : null;
    }
1145029
def _elements(self):
        
        if not self.evaluated:
            setattr(self, '_elements_cached', list(self._select()))
        return self._elements_cached
298628
def refs(self):
        
        out_refs = IterableList(RemoteReference._id_attribute_, "%s/" % self.name)
        out_refs.extend(RemoteReference.list_items(self.repo, remote=self.name))
        return out_refs
594458
def children(self):
        
        new_refs = set()
        output = []
        for ref in self._children:
            item = ref()
            if item is not None:
                output.append(item)
                new_refs.add(ref)
        
        self._children = new_refs
        return output
665993
Iterable<Object> getHardReferences() {
        final List<Object> references = new ArrayList<Object>(hardReferences.size());
        for (final HardReference reference : hardReferences) {
            references.add(reference.referenceToKeep);
        }
        return references;
    }
157405
public List<BeanId> getReferences() {
        if (references == null) {
            return new ArrayList<>();
        }
        ArrayList<BeanId> result = new ArrayList<>();
        for (List<BeanId> b : references.values()) {
            if (b != null) {
                result.addAll(b);
            }

        }
        return result;
    }
486168
def iter_links_element(self, element):
        ''''''
        # reference: lxml.html.HtmlMixin.iterlinks()
        attrib = element.attrib
        tag = element.tag

        if tag == 'link':
            iterable = self.iter_links_link_element(element)
        elif tag == 'meta':
            iterable = self.iter_links_meta_element(element)
        elif tag in ('object', 'applet'):
            iterable = self.iter_links_object_element(element)
        elif tag == 'param':
            iterable = self.iter_links_param_element(element)
        elif tag == 'style':
            iterable = self.iter_links_style_element(element)
        elif tag == 'script':
            iterable = self.iter_links_script_element(element)
        else:
            iterable = self.iter_links_plain_element(element)

        # RSS/Atom
        if tag in ('link', 'url', 'icon'):
            iterable = itertools.chain(
                iterable, self.iter_links_element_text(element)
            )

        for link_info in iterable:
            yield link_info

        if 'style' in attrib and self.css_scraper:
            for link in self.css_scraper.scrape_links(attrib['style']):
                yield LinkInfo(
                    element=element, tag=element.tag, attrib='style',
                    link=link,
                    inline=True, linked=False,
                    base_link=None,
                    value_type='css',
                    link_type=LinkType.media,
                )
833101
def reference(node):
    
    o = nodes.reference()
    o['refuri'] = node.destination
    if node.title:
        o['name'] = node.title
    for n in MarkDown(node):
        o += n
    return o
545848
def get_ref(self):
        
        if self.ref_key == 'NETWORK':
            return self.network
        elif self.ref_key == 'NODE':
            return self.node
        elif self.ref_key == 'LINK':
            return self.link
        elif self.ref_key == 'GROUP':
            return self.group
        elif self.ref_key == 'SCENARIO':
            return self.scenario
        elif self.ref_key == 'PROJECT':
            return self.project
1063188
def external_commands(self):
        
        res = []
        with self.app.external_commands_lock:
            for cmd in self.app.get_external_commands():
                res.append(cmd.serialize())
        return res
456751
private Iterator<ConcurrentServiceReferenceElement<T>> elements() {
        Collection<ConcurrentServiceReferenceElement<T>> set;
        synchronized (elementMap) {
            if (elementSetUnsorted) {
                elementSet = new ConcurrentSkipListSet<ConcurrentServiceReferenceElement<T>>(elementMap.values());
                elementSetUnsorted = false;
            }
            set = elementSet;
        }

        return set.iterator();
    }