@param $room

@return array
975122
protected function filterGetRooms($room): array
    {
        $prefix = $this->channelPrefix();

        return array_map(function ($room) use ($prefix) {
            return $prefix.$room;
        }, array_filter((array) $room, function ($value) {
            return !is_int($value);
        }));
    }
725840
public function getValues($language = null)
    {
        if (!$language) {
            $language = $this->defaultLanguage;
        }

        if (!isset($this->values[$language])) {
            return [];
        }

        return $this->values[$language];
    }
671193
public function getTableColumns(string $table): array {
		$query = <<<QUERY
			SELECT COLUMN_NAME
			FROM INFORMATION_SCHEMA.COLUMNS
			WHERE TABLE_SCHEMA = :database
			AND TABLE_NAME = :table
QUERY;
		
		$params = [
			"database" => $this->database,
			"table"    => $table,
		];
		
		try {
			$results = $this->getCol($query, $params);
			return is_array($results) ? $results : [];
		} catch (\PDOException $databaseException) {
			throw $this->prepareDatabaseException($databaseException, $query, $params);
		}
	}
130359
protected function parseEntry($entry)
    {
        if (!get_property($entry, 'url')) {
            throw new \InvalidArgumentException('Url is missing or not accessible.');
        }
        $url        = get_property($entry, 'url');
        $lastmod    = get_property($entry, 'lastmod');
        $changefreq = get_property($entry, 'changefreq');
        $priority   = get_property($entry, 'priority');

        return [$url, $lastmod, $changefreq, $priority];
    }
404253
public function getColumns(): array
    {
        $tSelects = isset($this->statements['selects']) === true ? $this->statements['selects'] : [];
        $tColumns = [];
        foreach ($tSelects as $key => $value) {
            if (\is_string($value)) {
                if (\is_int($key)) {
                    $tElements = explode('.', $value);
                    if (!\in_array('*', $tElements, true)) {
                        $tColumns[$tElements[1] ?? $tElements[0]] = $value;
                    }
                } elseif (\is_string($key)) {
                    $tColumns[$value] = $key;
                }
            }
        }
        return $tColumns;
    }
80117
public function getColumns($table)
    {
        $query = $this->getUtilityQuery()->showColumns($table);

        $results = $this->query($query, $this->getBinds());
        
        $columns = [];
        foreach ($results as $column) {
            $key = null;
            if ($column['pk'] == 1) {
                $key = 'PRI';
            }
            
            $columns[] = [
                'Field'     => $column['name'],
                'Type'      => $column['type'],
                'Default'   => $column['dflt_value'],
                'Null'      => $column['notnull'] != 1,
                'Key'       => $key
            ];
        }
        
        return $columns;
    }
145651
protected function getPropertiesFromAtomEntry(Entry $entry)
    {
        $result = [];
        $content = $entry->getContent();
        if (!empty($content)) {
            $result = ContentPropertiesSerializer::unserialize(
                $content->getXml()->children(Resources::DSM_XML_NAMESPACE)
            );
        }

        return $result;
    }
378891
public function getExtractorsForTable(string $tableName): array
    {
        if (!isset($this->tableExtractors[$tableName])) {
            return [];
        }
        $extractors = [];
        foreach ($this->tableExtractors[$tableName] as $tableExtractor) {
            if (!$this->extractorContainer->has($tableExtractor)) {
                throw new \RuntimeException('Could not get extractor ' . $tableExtractor);
            }
            $extractors[] = $extractor = $this->extractorContainer->get($tableExtractor);
            $this->logger->debug('Adding extractor ' . $extractor->name());
        }

        return $extractors;
    }
1050689
final static function getEntries(): array {
    static $entries;
    if (!isset($entries)) {
      $entries = [];
      foreach ((new \ReflectionClass(static::class))->getConstants() as $name => $value) {
        $reflection = new \ReflectionClassConstant(static::class, $name);
        if ($reflection->isPublic()) $entries[$name] = $reflection->getValue();
      }
    }

    return $entries;
  }
1342027
public function rooms(int $fd): array
    {
        $rooms = $this->room->keys($fd);

        $prefix = $this->channelPrefix();

        return array_filter($rooms, function (string $room) use ($prefix) {
            return strpos($room, $prefix) !== false;
        });
    }
74830
@SuppressWarnings("unchecked")
    @Override
	public <T extends ApiRoom> List<T> getRoomList() {
	    List<Room> sfsRooms = getZone().getRoomList();
        List<T> answer = new ArrayList<>();
        for(Room sfsRoom : sfsRooms) {
            if(sfsRoom.containsProperty(APIKey.ROOM))
                answer.add((T) sfsRoom.getProperty(APIKey.ROOM));
        }
        return answer;
	}
1165828
public function removeRoom(\Ydle\HubBundle\Entity\Room $rooms)
    {
        $this->rooms->removeElement($rooms);
    }
752122
public function getArrayRolesByWorkspace(Workspace $workspace)
    {
        $workspaceRoles = [];
        $uow = $this->om->getUnitOfWork();
        $wRoles = $this->roleManager->getRolesByWorkspace($workspace);
        $scheduledForInsert = $uow->getScheduledEntityInsertions();

        foreach ($scheduledForInsert as $entity) {
            if ('Claroline\CoreBundle\Entity\Role' === get_class($entity)) {
                if ($entity->getWorkspace()) {
                    if ($entity->getWorkspace()->getGuid() === $workspace->getGuid()) {
                        $wRoles[] = $entity;
                    }
                }
            }
        }
        //now we build the array
        foreach ($wRoles as $wRole) {
            $workspaceRoles[$wRole->getTranslationKey()] = $wRole;
        }

        return $workspaceRoles;
    }
833300
public function getSpeakersByRoom(string $room): array
    {
        $return = [];

        $speakers = $this->getSpeakers();
        foreach ($speakers as $controller) {
            if ($controller->getRoom() === $room) {
                $return[] = $controller;
            }
        }

        return $return;
    }
1299833
private function buildItems(array $entries): array
    {
        return array_map(
            function (ContentfulEntry $entry): Item {
                return $this->buildItem($entry);
            },
            $entries
        );
    }
930011
def find_room_in_json(json)
      room_hash = json["rooms"].find { |r| r["name"] == room }

      if room_hash
        room_hash["id"]
      else
        raise NotFound, "Room name '#{room}' could not be found."
      end
    end
174237
@Override
    public <T extends ApiUser> List<T> in(ApiRoom room) {
        Room sfsRoom = CommandUtil.getSfsRoom(room, extension);
        validateRoom(sfsRoom, room);
        return CommandUtil.getApiUserList(sfsRoom.getUserList());
    }