Returns all rooms. For getting the users, each specific room must be queries with Firering.room
 multi: if true, gets all the users from each room as Firering::User objects
516641
def rooms(&callback)
      http(:get, "/rooms.json") do |data, http|
        if data && data[:rooms]
          callback.call(data[:rooms].map{|room| Firering::Room.instantiate(self, room)}) if callback
        else
          logger.error(http.response)
          callback.call([])
        end
      end
    end
132537
def room_members(self, stream_id):
        '''  '''
        req_hook = 'pod/v2/room/' + str(stream_id) + '/membership/list'
        req_args = None
        status_code, response = self.__rest__.GET_query(req_hook, req_args)
        self.logger.debug('%s: %s' % (status_code, response))
        return status_code, response
623094
def users(options = {})
      batches = Enumerator.new do |y|
        options = options.merge(group_name: @name)
        resp = @client.get_group(options)
        resp.each_page do |page|
          batch = []
          page.data.users.each do |u|
            batch << User.new(
              name: u.user_name,
              data: u,
              client: @client
            )
          end
          y.yield(batch)
        end
      end
      User::Collection.new(batches)
    end
614302
public List<User> getAllUsers() {
        List<User> r = new ArrayList<User>();
        for (User u : User.getAll()) {
            if(u.getProperty(Details.class)!=null)
                r.add(u);
        }
        Collections.sort(r);
        return r;
    }
452388
def get_gallery_all(self, username='', offset=0, limit=10):
        
        if not username:
            raise DeviantartError('No username defined.')

        response = self._req('/gallery/all', {'username': username,
                                               'offset': offset,
                                               'limit': limit})

        deviations = []

        for item in response['results']:
            d = Deviation()
            d.from_dict(item)
            deviations.append(d)

        if "name" in response:
            name = response['name']
        else:
            name = None

        return {
            "results": deviations,
            "name": name,
            "has_more": response['has_more'],
            "next_offset": response['next_offset']
        }
425566
def users(self):
        
        if not self.__users:
            self.__users = Users(self.__connection)
        return self.__users
700808
def get_all(cls, names):
        
        names = cls._get_iterable_for_names(names)

        queues = []
        for queue_name in names:
            queues.extend(cls.collection(name=queue_name).instances())

        return queues
1243911
def rooms(self):
        
        if self._rooms is None:
            self._rooms = RoomList(self)
        return self._rooms
1336618
def get_all(cls):
        '''  '''
        redis = cls.get_redis()

        return list(map(
            lambda id: cls.get(id),
            map(
                debyte_string,
                redis.smembers(cls.members_key())
            )
        ))
400397
def all(self):
        
        return self._client.get(
            url=self._client.get_full_url(
                self.get_path('collection', realm=self._realm_name)
            )
        )
392353
public java.util.List<User> getUsers() {
        if (users == null) {
            users = new com.amazonaws.internal.SdkInternalList<User>();
        }
        return users;
    }
975367
def get_members(self, sort='id_asc'):
        
        return self._session.fetch_items("groups.getMembers", User.from_json, 1000, group_id=self.id, sort=sort, fields=User.__slots__ + User.USER_FIELDS)
67645
def getall(self):
        
        users = self.users_re.findall(self.config, re.M)
        resources = dict()
        for user in users:
            resources.update(self._parse_username(user))
        return resources
913550
def get_users(self, fetch=True):
        """"""
        return Users(self.resource.users, self.client, populate=fetch)
229998
def get_joined_members(self, force_resync=False) -> List[User]:
        
        if force_resync:
            response = self.client.api.get_room_members(self.room_id)
            for event in response['chunk']:
                if event['content']['membership'] == 'join':
                    user_id = event["state_key"]
                    if user_id not in self._members:
                        self._mkmembers(
                            User(
                                self.client.api,
                                user_id,
                                event['content'].get('displayname'),
                            ),
                        )
        return list(self._members.values())
675043
def users
      users = Set.new

      @channels.each do |channel|
        users.merge channel.users
      end

      users
    end
598677
public Iterator<QueueUser> getUsers() {
        if (users == null) {
            return new HashSet<QueueUser>().iterator();
        }
        return Collections.unmodifiableSet(users).iterator();
    }