Subclasses may want to sort this
175961
def df_all(self, phot):
        
        df = pd.concat([self.to_df(f) for f in self.get_filenames(phot)])
        return df
908940
def order(self):
        
        return [x.val for theclass in self.classes for x in theclass.items]
287035
def _next_class(cls):
        
        return next(
            class_
            for class_ in cls.__mro__
            if not issubclass(class_, Multi)
        )
24620
private String searchForPersistentSubType(XClass type)
    {
        ArrayList queue = new ArrayList();
        XClass    subType;

        queue.add(type);
        while (!queue.isEmpty())
        {
            subType = (XClass)queue.get(0);
            queue.remove(0);
            if (_model.hasClass(subType.getQualifiedName()))
            {
                return subType.getQualifiedName();
            }
            addDirectSubTypes(subType, queue);
        }
        return null;
    }
1247460
public static <T extends Class<?>> void sortByPriority(List<T> someClasses) {
        sortByPriority(someClasses, PriorityUtils::priorityOf);
    }
1031048
public void sort() {
        PriorityQueue<Op.Pair<Term, Double>> termCentroids
                = new PriorityQueue<Op.Pair<Term, Double>>(
                        terms.size(), new Ascending());
        Defuzzifier defuzzifier = new Centroid();
        for (Term term : terms) {
            double centroid;
            try {
                if (term instanceof Constant || term instanceof Linear) {
                    centroid = term.membership(0);
                } else {
                    centroid = defuzzifier.defuzzify(term, getMinimum(), getMaximum());
                }
            } catch (Exception ex) {
                centroid = Double.POSITIVE_INFINITY;
            }
            termCentroids.offer(new Op.Pair<Term, Double>(term, centroid));
        }

        List<Term> sortedTerms = new ArrayList<Term>(terms.size());
        while (!termCentroids.isEmpty()) {
            sortedTerms.add(termCentroids.poll().getFirst());
        }
        setTerms(sortedTerms);
    }
1040570
def all_subclasses(cls):
    
    subclasses = cls.__subclasses__()
    descendants = (descendant for subclass in subclasses
                   for descendant in all_subclasses(subclass))
    return set(subclasses) | set(descendants)
1321712
def sorted_for_ner(crf_classes):
    
    def key(cls):
        if len(cls) > 2 and cls[1] == '-':
            # group names like B-ORG and I-ORG together
            return cls.split('-', 1)[1], cls
        return '', cls
    return sorted(crf_classes, key=key)
471229
def top_class(self):
        """"""
        curr = self
        parent = self.parent
        while isinstance(parent, class_t):
            curr = parent
            parent = parent.parent
        return curr
168128
def sort(self, callback=None):
        
        items = self.items

        if callback:
            return self.__class__(sorted(items, key=callback))
        else:
            return self.__class__(sorted(items))
1123954
private void sort(InstructionGroup group) {
        final InsnList instructions = method.instructions;
        Collections.sort(group.getNodes(), new Comparator<InstructionGraphNode>() {
            public int compare(InstructionGraphNode a, InstructionGraphNode b) {
                return Integer.valueOf(instructions.indexOf(a.getInstruction()))
                        .compareTo(instructions.indexOf(b.getInstruction()));
            }
        });
    }
738551
def sorted(self, by, **kwargs):
        
        sort_idc = np.argsort(self[by], **kwargs)
        return self.__class__(
            self[sort_idc],
            h5loc=self.h5loc,
            split_h5=self.split_h5,
            name=self.name
        )
628151
def lookup_subclass(cls, d):
        
        try:
            typeid = d["typeid"]
        except KeyError:
            raise FieldError("typeid not present in keys %s" % list(d))

        subclass = cls._subcls_lookup.get(typeid, None)
        if not subclass:
            raise FieldError("'%s' not a valid typeid" % typeid)
        else:
            return subclass
455082
def get_recursive_subclasses(cls):
    """"""
    return cls.__subclasses__() + [g for s in cls.__subclasses__() for g in get_recursive_subclasses(s)]
373434
def get_interesting_members(base_class, cls):
    """"""

    base_members = dir(base_class)
    predicate = inspect.ismethod if _py2 else inspect.isfunction
    all_members = inspect.getmembers(cls, predicate=predicate)
    return [member for member in all_members
            if not member[0] in base_members
            and ((hasattr(member[1], "__self__") and not member[1].__self__ in inspect.getmro(cls)) if _py2 else True)
            and not member[0].startswith("_")
            and not member[0].startswith("before_")
            and not member[0].startswith("after_")]
927247
def all_subclasses(cls):
    """"""
    for subcls in cls.__subclasses__():
        yield subcls
        for subsubcls in all_subclasses(subcls):
            yield subsubcls
1055822
function _fnSortingClasses( settings )
	{
		var oldSort = settings.aLastSort;
		var sortClass = settings.oClasses.sSortColumn;
		var sort = _fnSortFlatten( settings );
		var features = settings.oFeatures;
		var i, ien, colIdx;
	
		if ( features.bSort && features.bSortClasses ) {
			// Remove old sorting classes
			for ( i=0, ien=oldSort.length ; i<ien ; i++ ) {
				colIdx = oldSort[i].src;
	
				// Remove column sorting
				$( _pluck( settings.aoData, 'anCells', colIdx ) )
					.removeClass( sortClass + (i<2 ? i+1 : 3) );
			}
	
			// Add new column sorting
			for ( i=0, ien=sort.length ; i<ien ; i++ ) {
				colIdx = sort[i].src;
	
				$( _pluck( settings.aoData, 'anCells', colIdx ) )
					.addClass( sortClass + (i<2 ? i+1 : 3) );
			}
		}
	
		settings.aLastSort = sort;
	}