def find_users(*criteria)
      poll(:find_users, *criteria).
        collect { |result, authority| result }.
        compact.
        inject([]) { |aggregate, users| merge_user_lists!(aggregate, users.compact) }.
        each { |user| amplify!(user) }
    end
def find_users(*criteria)
      poll(:find_users, *criteria).
        collect { |result, authority| result }.
        compact.
        inject([]) { |aggregate, users| merge_user_lists!(aggregate, users.compact) }.
        each { |user| amplify!(user) }
    end
Finds users matching the given criteria.  Criteria may either be
 `String`s or `Hash`es.  If it's a single `String`, it is
 interpreted as a username and this method will return an array
 containing either a single user with that username or an empty
 array.  If the criteria is a `Hash`, the behavior will be
 authority-dependent.  However, all the attributes of
 {Aker::User} are reserved parameter names &mdash; if an
 authority interprets the value associated with a {Aker::User}
 attribute name, it must be interpreted as an exact-match
 criteria for that authority's understanding of that attribute
 (whatever it is).

 If more than one criterion is provided, each value is treated
 separately according to the description given above for a single
 value.  The resulting array will contain each matching user
 exactly once.  It will not be possible to determine from the
 results alone which returned user matched which criterion.

 Examples:

     authority.find_users("wakibbe") # => that single user, if
                                     #    the username is known
     authority.find_users(:first_name => 'Warren')
                                     # => all the users named
                                     #    Warren
     authority.find_users(
       :first_name => 'Warren', :last_name => 'Kibbe')
                                     # => all the users named
                                     #    Warren Kibbe
     authority.find_users(
       { :first_name => 'Warren' }, { :last_name => 'Kibbe' })
                                     # => all the users with
                                     #    first name Warren or
                                     #    last name Kibbe

 The composite behavior is to invoke `find_users` on all the
 authorities which support it and merge the resulting lists.  Any
 users with the same username are merged using
 {Aker::User#merge!}.  Finally, all the users are {#amplify!
 amplified}.

 This method will always return an array.

 @param [Array<Hash,#to_s>] criteria (see above)

 @return [Array<Aker::User>] the matching users