Sorts the set of Member Objects

@param members a set of Member objects to be sorted
@return a list of sorted Member objects
499340
public List<Entity> sortEntities(List<Entity> entities) {
        if (entities != null && entities.size() > 0) {
            Entity[] ents = (Entity[]) entities.toArray(new Entity[entities.size()]);
            WIMSortCompare<Entity> wimSortComparator = new WIMSortCompare<Entity>(sortControl);
            Arrays.sort(ents, wimSortComparator);
            entities.clear();
            for (int i = 0; i < ents.length; i++) {
                entities.add(ents[i]);
            }
        }
        return entities;
    }
697935
List<MemberState> getActiveMemberStates(Comparator<MemberState> comparator) {
    List<MemberState> activeMembers = new ArrayList<>(getActiveMemberStates());
    Collections.sort(activeMembers, comparator);
    return activeMembers;
  }
1346437
public static MembersView createNew(int version, Collection<MemberImpl> members) {
        List<MemberInfo> list = new ArrayList<>(members.size());

        for (MemberImpl member : members) {
            list.add(new MemberInfo(member));
        }

        return new MembersView(version, unmodifiableList(list));
    }
416165
private static int[] filterBySetPos(int[] members, int[] bySetPos) {
        members = Util.uniquify(members);
        IntSet iset = new IntSet();
        for (int pos : bySetPos) {
            if (pos == 0) {
                continue;
            }
            if (pos < 0) {
                pos += members.length;
            } else {
                --pos;  // Zero-index.
            }
            if (pos >= 0 && pos < members.length) {
                iset.add(members[pos]);
            }
        }
        return iset.toIntArray();
    }
114571
public static <T extends Comparable<? super T>> List<T> sortInplace(List<T> list) {
		Collections.sort(list);
		return list;
	}
352313
def sort_members(tup, names):
  
  scalars, tuples = partition(lambda x: not is_tuple_node(tup.member[x].value), names)
  unbound, bound = partition(lambda x: tup.member[x].value.is_unbound(), scalars)
  return usorted(unbound) + usorted(bound), usorted(tuples)
785639
public Set<DetectorFactory> getUnpositionedMembers() {
        HashSet<DetectorFactory> result = new HashSet<>(memberSet);
        result.removeAll(orderedFactoryList);
        return result;
    }
1120209
public List<MemberState> getRemoteMemberStates(Member.Type type) {
    List<MemberState> members = memberTypes.get(type);
    return members != null ? members : Collections.EMPTY_LIST;
  }
986814
public Collection<Member> members(MemberFilter filter) {
        return get(Member.class, (filter != null) ? filter : new MemberFilter());
    }
880018
List<MemberState> getPassiveMemberStates(Comparator<MemberState> comparator) {
    List<MemberState> passiveMembers = new ArrayList<>(getPassiveMemberStates());
    Collections.sort(passiveMembers, comparator);
    return passiveMembers;
  }
1049156
public java.util.List<String> getMemberClusters() {
        if (memberClusters == null) {
            memberClusters = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return memberClusters;
    }
809634
private int getDataMemberListIndex(Member member) {
        final Collection<Member> dataMembers = nodeEngine.getClusterService().getMembers(DATA_MEMBER_SELECTOR);
        int index = -1;
        for (Member dataMember : dataMembers) {
            index++;
            if (dataMember.equals(member)) {
                return index;
            }
        }
        return index;
    }
1118983
private static Sort getSort(String... columnNames) {
        Sort key = null;
        for (String s : columnNames) {
            if (key == null) {
                key = first(s, Sort.Order.DESCEND);
            } else {
                key.next(s, Sort.Order.DESCEND);
            }
        }
        return key;
    }
877390
public void setMemberAccounts(java.util.Collection<String> memberAccounts) {
        if (memberAccounts == null) {
            this.memberAccounts = null;
            return;
        }

        this.memberAccounts = new java.util.ArrayList<String>(memberAccounts);
    }
4103
public static <E extends Comparable<E>> void sort(List<E> list) {
        Merge.sort(list, 0, list.size()-1, false);
    }
1074685
public Iterable<BoxGroupMembership.Info> getAllMemberships(String ... fields) {
        final QueryStringBuilder builder = new QueryStringBuilder();
        if (fields.length > 0) {
            builder.appendParam("fields", fields);
        }
        return new Iterable<BoxGroupMembership.Info>() {
            public Iterator<BoxGroupMembership.Info> iterator() {
                URL url = USER_MEMBERSHIPS_URL_TEMPLATE.buildWithQuery(
                        BoxUser.this.getAPI().getBaseURL(), builder.toString(), BoxUser.this.getID());
                return new BoxGroupMembershipIterator(BoxUser.this.getAPI(), url);
            }
        };
    }
1200540
protected List<OrderMember> getMembers(HierarchicalProperty body)
   {
      ArrayList<OrderMember> members = new ArrayList<OrderMember>();
      List<HierarchicalProperty> childs = body.getChildren();
      for (int i = 0; i < childs.size(); i++)
      {
         OrderMember member = new OrderMember(childs.get(i));
         members.add(member);
      }
      return members;
   }