introduce extendable tree structure for holding the nested room infos

Instead of creating a nested map on demand for the nested room infos,
move to an extendable tree structure described by explicit types. This
makes the information structure clearer and allows for easily adding
information at various levels in the future.

main.go

@@ -41,6 +41,28 @@ type VersionPath struct {
 	Version        string
 }
 
+type RoomInfoTree map[id.RoomID](*RoomInfo)
+
+type RoomInfo struct {
+	MaxRoomVersions map[string](*MaxRoomVersionInfo)
+}
+
+type MaxRoomVersionInfo struct {
+	Servers map[string](*ServerInfo)
+}
+
+type ServerInfo struct {
+	Versions map[string](*VersionInfo)
+}
+
+type VersionInfo struct {
+	Homeservers map[string](*HomeserverInfo)
+}
+
+type HomeserverInfo struct {
+	MemberCount uint
+}
+
 var unknownServerVersionInfo = fclient.Version{
 	Server: struct {
 		Name    string `json:"name"`
@@ -362,7 +384,7 @@ func main() {
 	serverVersionInfoByHomeserver := getServerVersionInfoByHomeserver(homeservers, federationClient)
 
 	// Info map tree.
-	roomMaxVersionInfos := make(map[id.RoomID](map[string](map[string](map[string](map[string]uint)))))
+	roomInfoTree := make(RoomInfoTree)
 	// Member counters.
 	membersByRoomID := make(map[id.RoomID]uint)
 	membersByMaxRoomVersion := make(map[MaxRoomVersionPath]uint)
@@ -381,77 +403,82 @@ func main() {
 			membersByServerPath[ServerPath{roomID, maxRoomVersion, serverVersionInfo.Server.Name}] += members
 			membersByVersionPath[VersionPath{roomID, maxRoomVersion, serverVersionInfo.Server.Name, serverVersionInfo.Server.Version}] += members
 
-			// Sort into roomMaxVersionInfos map tree.
-			maxRoomVersionMap, ok := roomMaxVersionInfos[roomID]
+			// Sort into roomInfoTree.
+			roomInfo, ok := roomInfoTree[roomID]
 			if !ok {
-				maxRoomVersionMap = make(map[string](map[string](map[string](map[string]uint))))
-				roomMaxVersionInfos[roomID] = maxRoomVersionMap
+				roomInfo = &RoomInfo{MaxRoomVersions: make(map[string]*MaxRoomVersionInfo)}
+				roomInfoTree[roomID] = roomInfo
 			}
-			serverMap, ok := maxRoomVersionMap[maxRoomVersion]
+			maxRoomVersionInfo, ok := roomInfo.MaxRoomVersions[maxRoomVersion]
 			if !ok {
-				serverMap = make(map[string](map[string](map[string]uint)))
-				maxRoomVersionMap[maxRoomVersion] = serverMap
+				maxRoomVersionInfo = &MaxRoomVersionInfo{Servers: make(map[string]*ServerInfo)}
+				roomInfo.MaxRoomVersions[maxRoomVersion] = maxRoomVersionInfo
 			}
-			versionMap, ok := serverMap[serverVersionInfo.Server.Name]
+			serverInfo, ok := maxRoomVersionInfo.Servers[serverVersionInfo.Server.Name]
 			if !ok {
-				versionMap = make(map[string](map[string]uint))
-				serverMap[serverVersionInfo.Server.Name] = versionMap
+				serverInfo = &ServerInfo{Versions: make(map[string]*VersionInfo)}
+				maxRoomVersionInfo.Servers[serverVersionInfo.Server.Name] = serverInfo
 			}
-			homeserverMap, ok := versionMap[serverVersionInfo.Server.Version]
+			versionInfo, ok := serverInfo.Versions[serverVersionInfo.Server.Version]
 			if !ok {
-				homeserverMap = make(map[string]uint)
-				versionMap[serverVersionInfo.Server.Version] = homeserverMap
+				versionInfo = &VersionInfo{Homeservers: make(map[string]*HomeserverInfo)}
+				serverInfo.Versions[serverVersionInfo.Server.Version] = versionInfo
 			}
-			homeserverMap[hs] = members
+			homeserverInfo, ok := versionInfo.Homeservers[hs]
+			if !ok {
+				homeserverInfo = &HomeserverInfo{}
+				versionInfo.Homeservers[hs] = homeserverInfo
+			}
+			homeserverInfo.MemberCount = members
 		}
 	}
 
-	for roomID, roomIDValue := range roomMaxVersionInfos {
+	for roomID, roomInfo := range roomInfoTree {
 		fmt.Println("Room:")
 		fmt.Printf("  %s -> %d\n", givenRoomsByRoomID[roomID], membersByRoomID[roomID])
 
 		fmt.Println("Version Support:")
 
-		maxRoomVersionKeys := make([]string, 0, len(roomIDValue))
-		for key := range roomIDValue {
+		maxRoomVersionKeys := make([]string, 0, len(roomInfo.MaxRoomVersions))
+		for key := range roomInfo.MaxRoomVersions {
 			maxRoomVersionKeys = append(maxRoomVersionKeys, key)
 		}
 		slices.SortFunc(maxRoomVersionKeys, compareVersionStrings)
 		for _, maxRoomVersionKey := range maxRoomVersionKeys {
-			maxRoomVersionValue := roomIDValue[maxRoomVersionKey]
+			maxRoomVersionInfo := roomInfo.MaxRoomVersions[maxRoomVersionKey]
 
 			fmt.Printf("  %s -> %d\n", maxRoomVersionKey, membersByMaxRoomVersion[MaxRoomVersionPath{roomID, maxRoomVersionKey}])
 
-			serverKeys := make([]string, 0, len(maxRoomVersionValue))
-			for key := range maxRoomVersionValue {
+			serverKeys := make([]string, 0, len(maxRoomVersionInfo.Servers))
+			for key := range maxRoomVersionInfo.Servers {
 				serverKeys = append(serverKeys, key)
 			}
 			sort.Strings(serverKeys)
 			for _, serverKey := range serverKeys {
-				serverValue := maxRoomVersionValue[serverKey]
+				serverInfo := maxRoomVersionInfo.Servers[serverKey]
 
 				fmt.Printf("    %s -> %d\n", serverKey, membersByServerPath[ServerPath{roomID, maxRoomVersionKey, serverKey}])
 
-				versionKeys := make([]string, 0, len(serverValue))
-				for key := range serverValue {
+				versionKeys := make([]string, 0, len(serverInfo.Versions))
+				for key := range serverInfo.Versions {
 					versionKeys = append(versionKeys, key)
 				}
 				slices.SortFunc(versionKeys, compareVersionStrings)
 				for _, versionKey := range versionKeys {
-					versionValue := serverValue[versionKey]
+					versionInfo := serverInfo.Versions[versionKey]
 
 					fmt.Printf("      %s -> %d\n", versionKey, membersByVersionPath[VersionPath{roomID, maxRoomVersionKey, serverKey, versionKey}])
 
 					if config.PrintHomeserverMemberCount {
-						homeserverKeys := make([]string, 0, len(versionValue))
-						for key := range versionValue {
+						homeserverKeys := make([]string, 0, len(versionInfo.Homeservers))
+						for key := range versionInfo.Homeservers {
 							homeserverKeys = append(homeserverKeys, key)
 						}
 						sort.Strings(homeserverKeys)
 						for _, homeserverKey := range homeserverKeys {
-							homeserverValue := versionValue[homeserverKey]
+							homeserverInfo := versionInfo.Homeservers[homeserverKey]
 
-							fmt.Printf("        %s -> %d\n", homeserverKey, homeserverValue)
+							fmt.Printf("        %s -> %d\n", homeserverKey, homeserverInfo.MemberCount)
 						}
 					}
 				}