Get the lineages for the controller's specified surname
184541
protected function getLineages() {		
        $builder = new LineageBuilder($this->surname, Globals::getTree());
		$lineages = $builder->buildLineages();
		
    	return $lineages;
    }
335015
def getAncestorsUIDs(instance):
    
    request = instance.getRequest()
    parents = map(lambda ar: api.get_uid(ar), request.getAncestors())
    return [api.get_uid(request)] + parents
525265
def desc(self):
        """"""
        doc = inspect.getdoc(self.controller_class)
        if not doc: doc = ''
        return doc
814625
def controller_info(self):
        """"""

        return [self._device.iotile_id, _pack_version(*self.os_info), _pack_version(*self.app_info)]
244397
private GVRCursorController getUniqueControllerId(int deviceId) {
        GVRCursorController controller = controllerIds.get(deviceId);
        if (controller != null) {
            return controller;
        }
        return null;
    }
491266
public String getFamilyName() {
    if (DocumentSpecies_Type.featOkTst && ((DocumentSpecies_Type)jcasType).casFeat_familyName == null)
      jcasType.jcas.throwFeatMissing("familyName", "ch.epfl.bbp.uima.types.DocumentSpecies");
    return jcasType.ll_cas.ll_getStringValue(addr, ((DocumentSpecies_Type)jcasType).casFeatCode_familyName);}
610314
def _ancestors(
            self, qname: Union[QualName, bool] = None) -> List[InstanceNode]:
        """"""
        return self.up()._ancestors(qname)
216712
def get_ancestors(self, include_self=False, depth=None):
        """"""
        if self.is_root_node():
            if not include_self:
                return self._toplevel().objects.none()
            else:
                # Filter on pk for efficiency.
                return self._toplevel().objects.filter(pk=self.pk)

        params = {"%s__child" % self._closure_parentref():self.pk}
        if depth is not None:
            params["%s__depth__lte" % self._closure_parentref()] = depth
        ancestors = self._toplevel().objects.filter(**params)
        if not include_self:
            ancestors = ancestors.exclude(pk=self.pk)
        return ancestors.order_by("%s__depth" % self._closure_parentref())
525351
def family_name(self):
        
        def find_first(dict_, keys, default=None):
            for key in keys:
                value = dict_.get(key)
                if value is not None:
                    return value
            return default
        # keys for Unicode, Mac, and Windows family name, respectively
        return find_first(self._names, ((0, 1), (1, 1), (3, 1)))
351203
def _find_family_class(dev):
        """"""
        for familyInfo in FAMILIES:
            # Skip if wrong vendor.
            if dev.vendor != familyInfo.vendor:
                continue

            # Scan each level of families
            for familyName in dev.families:
                for regex in familyInfo.matches:
                    # Require the regex to match the entire family name.
                    match = regex.match(familyName)
                    if match and match.span() == (0, len(familyName)):
                        return familyInfo.klass
        else:
            # Default target superclass.
            return CoreSightTarget
986550
def _get_catalog_idstrs(self):
        """"""
        if self._catalog_view == ISOLATED:
            return [str(self._catalog_id)]
        else:
            return self._get_descendent_cat_idstrs(self._catalog_id)
721630
def _get_ancestors_path(self, model, levels=None):
        
        if not issubclass(model, self.model):
            raise ValueError(
                "%r is not a subclass of %r" % (model, self.model))

        ancestry = []
        # should be a OneToOneField or None
        parent_link = model._meta.get_ancestor_link(self.model)
        if levels:
            levels -= 1
        while parent_link is not None:
            related = parent_link.remote_field
            ancestry.insert(0, related.get_accessor_name())
            if levels or levels is None:
                parent_model = related.model
                parent_link = parent_model._meta.get_ancestor_link(
                    self.model)
            else:
                parent_link = None
        return LOOKUP_SEP.join(ancestry)
881826
def getUserName(self):
        """"""
        if not self._server_side:
            return
        mech = self._authenticator.current_mech
        return mech.getUserName() if mech else None
889935
def full_name(self):
        """"""
        if self._full_name is None:
            ancestors = [ self.name ]
            current = self.parent
            while current is not None and type(current).__name__ != "CodeParser":
                ancestors.append(current.name)
                current = current.parent

            self._full_name = ".".join(reversed(ancestors))
        
        return self._full_name
197631
def get_build_controllers(self, name=None):
        
        query_parameters = {}
        if name is not None:
            query_parameters['name'] = self._serialize.query('name', name, 'str')
        response = self._send(http_method='GET',
                              location_id='fcac1932-2ee1-437f-9b6f-7f696be858f6',
                              version='5.0',
                              query_parameters=query_parameters)
        return self._deserialize('[BuildController]', self._unwrap_collection(response))
648563
def family_ids(force_reload=false)
      return @family_ids unless @family_ids.nil? or force_reload
      
      transaction do
        reload_boundaries
        query = "SELECT id FROM #{self.class.quote_db_property(base_class.table_name)} " + 
                "WHERE #{nested_set_column(:left)} >= #{left} AND #{nested_set_column(:right)} <= #{right} " +
                "ORDER BY #{nested_set_column(:left)}"
        @family_ids = base_class.connection.select_values(query).map(&:to_i)
      end
    end
431008
def get_family(self):
        
        if self._lookup_session is None:
            mgr = get_provider_manager('RELATIONSHIP', runtime=self._runtime, proxy=self._proxy)
            self._lookup_session = mgr.get_family_lookup_session(proxy=getattr(self, "_proxy", None))
        return self._lookup_session.get_family(Id(self._my_map['id']))