Use simpler map for models

Need to keep old constructor and make a temporary one with an ignored
argument to make this work (since arguments will be equal due to type erasure)

1 files changed, 38 insertions, 47 deletions

diff --git a/config-model-api/src/main/java/com/yahoo/config/model/api/SuperModel.java b/config-model-api/src/main/java/com/yahoo/config/model/api/SuperModel.java
index d03824120d8..dccbc143c01 100644
--- a/config-model-api/src/main/java/com/yahoo/config/model/api/SuperModel.java
+++ b/config-model-api/src/main/java/com/yahoo/config/model/api/SuperModel.java
@@ -1,24 +1,35 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 package com.yahoo.config.model.api;
 
+import com.google.common.collect.ImmutableMap;
 import com.yahoo.config.provision.ApplicationId;
 import com.yahoo.config.provision.TenantName;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
 public class SuperModel {
-    private final Map<TenantName, Map<ApplicationId, ApplicationInfo>> models;
+
+    private final Map<ApplicationId, ApplicationInfo> models;
 
     public SuperModel() {
         this.models = Collections.emptyMap();
     }
 
+    // TODO: Remove when oldest model used is 6.309 or newer
     public SuperModel(Map<TenantName, Map<ApplicationId, ApplicationInfo>> models) {
+        this.models = new LinkedHashMap<>();
+        models.values().forEach(entry -> entry.forEach(this.models::put));
+    }
+
+    // TODO: The ignored parameter is just to circumvent the fact that you cannot have
+    // two constructors with same type erasure, the above will be removed and this one can
+    // be fixed
+    public SuperModel(Map<ApplicationId, ApplicationInfo> models, boolean ignored) {
         this.models = models;
     }
 
@@ -27,65 +38,45 @@ public class SuperModel {
      * TODO: Make the returned map immutable (and type to Map&lt;ApplicationId, ApplicationInfo&gt;)
      */
     public Map<TenantName, Map<ApplicationId, ApplicationInfo>> getAllModels() {
-        return models;
+        Map<TenantName, Map<ApplicationId, ApplicationInfo>> newModels = new LinkedHashMap<>();
+
+        this.models.forEach((key, value) -> {
+            if (!newModels.containsKey(key.tenant())) {
+                newModels.put(key.tenant(), new LinkedHashMap<>());
+            }
+            newModels.get(key.tenant()).put(key, value);
+        });
+        return newModels ;
+    }
+
+    public Map<ApplicationId, ApplicationInfo> getModels() {
+        return ImmutableMap.copyOf(models);
     }
 
     public List<ApplicationInfo> getAllApplicationInfos() {
-        return models.values().stream().flatMap(entry -> entry.values().stream()).collect(Collectors.toList());
+        return new ArrayList<>(models.values());
     }
 
     public Optional<ApplicationInfo> getApplicationInfo(ApplicationId applicationId) {
-        Map<ApplicationId, ApplicationInfo> tenantInfo = models.get(applicationId.tenant());
-        if (tenantInfo == null) {
-            return Optional.empty();
-        }
-
-        ApplicationInfo applicationInfo = tenantInfo.get(applicationId);
-        if (applicationInfo == null) {
-            return Optional.empty();
-        }
-
-        return Optional.of(applicationInfo);
+        ApplicationInfo applicationInfo = models.get(applicationId);
+        return applicationInfo == null ? Optional.empty() : Optional.of(applicationInfo);
     }
 
     public SuperModel cloneAndSetApplication(ApplicationInfo application) {
-        TenantName tenant = application.getApplicationId().tenant();
-        Map<TenantName, Map<ApplicationId, ApplicationInfo>> newModels = cloneModels(models);
-        if (!newModels.containsKey(tenant)) {
-            // New application has been activated
-            newModels.put(tenant, new LinkedHashMap<>());
-        } else {
-            // Application has been redeployed
-        }
-
-        newModels.get(tenant).put(application.getApplicationId(), application);
-
-        return new SuperModel(newModels);
+        Map<ApplicationId, ApplicationInfo> newModels = cloneModels(models);
+        newModels.put(application.getApplicationId(), application);
+
+        return new SuperModel(newModels, false);
     }
 
     public SuperModel cloneAndRemoveApplication(ApplicationId applicationId) {
-        Map<TenantName, Map<ApplicationId, ApplicationInfo>> newModels = cloneModels(models);
-        if (newModels.containsKey(applicationId.tenant())) {
-            newModels.get(applicationId.tenant()).remove(applicationId);
-            if (newModels.get(applicationId.tenant()).isEmpty()) {
-                newModels.remove(applicationId.tenant());
-            }
-        }
+        Map<ApplicationId, ApplicationInfo> newModels = cloneModels(models);
+        newModels.remove(applicationId);
 
-        return new SuperModel(newModels);
+        return new SuperModel(newModels, false);
     }
 
-    private static Map<TenantName, Map<ApplicationId, ApplicationInfo>> cloneModels(
-            Map<TenantName, Map<ApplicationId, ApplicationInfo>> models) {
-        Map<TenantName, Map<ApplicationId, ApplicationInfo>> newModels = new LinkedHashMap<>();
-        for (Map.Entry<TenantName, Map<ApplicationId, ApplicationInfo>> entry : models.entrySet()) {
-            Map<ApplicationId, ApplicationInfo> appMap = new LinkedHashMap<>();
-            newModels.put(entry.getKey(), appMap);
-            for (Map.Entry<ApplicationId, ApplicationInfo> appEntry : entry.getValue().entrySet()) {
-                appMap.put(appEntry.getKey(), appEntry.getValue());
-            }
-        }
-
-        return newModels;
+    private static Map<ApplicationId, ApplicationInfo> cloneModels(Map<ApplicationId, ApplicationInfo> models) {
+        return new LinkedHashMap<>(models);
     }
 }