Оптимизировано потребление памяти за счет интернирования объектов и строк

Author: theshadowco

build.gradle.kts

@@ -55,7 +55,7 @@ dependencies {
 
     // прочее
     implementation("commons-io", "commons-io", "2.8.0")
-    implementation("com.github.1c-syntax", "utils", "0.5.1")
+    implementation("io.github.1c-syntax", "utils", "0.6.0")
     implementation("io.github.1c-syntax", "bsl-common-library", "0.5.1")
     implementation("io.github.1c-syntax", "supportconf", "0.14.0") {
         exclude("io.github.1c-syntax", "bsl-common-library")

src/main/java/com/github/_1c_syntax/bsl/mdo/Language.java

@@ -1,25 +1,25 @@
-/*
- * This file is a part of MDClasses.
- *
- * Copyright (c) 2019 - 2024
- * Tymko Oleg <olegtymko@yandex.ru>, Maximov Valery <maximovvalery@gmail.com> and contributors
- *
- * SPDX-License-Identifier: LGPL-3.0-or-later
- *
- * MDClasses is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3.0 of the License, or (at your option) any later version.
- *
- * MDClasses is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with MDClasses.
- */
-package com.github._1c_syntax.bsl.mdo;
+/*
+ * This file is a part of MDClasses.
+ *
+ * Copyright (c) 2019 - 2024
+ * Tymko Oleg <olegtymko@yandex.ru>, Maximov Valery <maximovvalery@gmail.com> and contributors
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ *
+ * MDClasses is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3.0 of the License, or (at your option) any later version.
+ *
+ * MDClasses is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with MDClasses.
+ */
+package com.github._1c_syntax.bsl.mdo;
 
 import com.github._1c_syntax.bsl.mdo.support.MultiLanguageString;
 import com.github._1c_syntax.bsl.mdo.support.ObjectBelonging;
@@ -33,8 +33,6 @@
 import lombok.ToString;
 import lombok.Value;
 
-import java.util.Map;
-
 /**
  * ВНИМАНИЕ!
  * Для формата EDT хранится в файле Configuration.mdo, т.е. отдельного файла нет
@@ -101,7 +99,7 @@ private static Language newLanguage(String name, String code) {
     return Language.builder()
       .name(name)
       .uuid("")
-      .synonym(new MultiLanguageString(Map.of(code, name)))
+      .synonym(MultiLanguageString.create(code, name))
       .mdoReference(MdoReference.create(
         MDOType.LANGUAGE,
         MDOType.LANGUAGE.getGroupName() + "." + name,

src/main/java/com/github/_1c_syntax/bsl/mdo/storage/form/FormHandler.java

@@ -21,11 +21,61 @@
  */
 package com.github._1c_syntax.bsl.mdo.storage.form;
 
+import com.github._1c_syntax.utils.GenericInterner;
+import com.github._1c_syntax.utils.StringInterner;
+import edu.umd.cs.findbugs.annotations.Nullable;
+import lombok.EqualsAndHashCode;
+import lombok.Value;
+import lombok.experimental.Accessors;
+
 /**
  * Обработчик события формы
- *
- * @param event Имя события
- * @param name  Имя обработчика (метода) формы
  */
-public record FormHandler(String event, String name) {
+@Value
+@EqualsAndHashCode
+public class FormHandler implements Comparable<FormHandler> {
+
+  private static final GenericInterner<FormHandler> interner = new GenericInterner<>();
+  private static final StringInterner stringInterner = new StringInterner();
+
+  @Accessors(fluent = true)
+  String event;
+  @Accessors(fluent = true)
+  String name;
+
+  private FormHandler(String event, String name) {
+    this.event = stringInterner.intern(event);
+    this.name = stringInterner.intern(name);
+  }
+
+  /**
+   * @param event Имя события
+   * @param name  Имя обработчика (метода) формы
+   */
+
+  public static FormHandler create(String event, String name) {
+    return new FormHandler(event, name).intern();
+  }
+
+  @Override
+  public int compareTo(@Nullable FormHandler formHandler) {
+    if (formHandler == null) {
+      return 1;
+    }
+
+    if (this.equals(formHandler)) {
+      return 0;
+    }
+
+    int compareResult = event.compareTo(formHandler.event);
+    if (compareResult != 0) {
+      return compareResult;
+    }
+
+    return name.compareTo(formHandler.name);
+  }
+
+  private FormHandler intern() {
+    return interner.intern(this);
+  }
 }

src/main/java/com/github/_1c_syntax/bsl/mdo/support/MultiLanguageString.java

@@ -21,44 +21,57 @@
  */
 package com.github._1c_syntax.bsl.mdo.support;
 
+import com.github._1c_syntax.utils.GenericInterner;
 import com.github._1c_syntax.utils.StringInterner;
+import edu.umd.cs.findbugs.annotations.Nullable;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
 import lombok.NonNull;
 import lombok.Value;
 
 import java.util.Collections;
-import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * Используется для хранения текстовой строки на разных языках
  */
 @Value
-public class MultiLanguageString {
+@EqualsAndHashCode
+public class MultiLanguageString implements Comparable<MultiLanguageString> {
 
   /**
    * Ссылка на пустой элемент
    */
   public static final MultiLanguageString EMPTY = new MultiLanguageString(Collections.emptyMap());
-
-  private static final StringInterner stringInterner = new StringInterner();
+  private static final GenericInterner<MultiLanguageString> interner = new GenericInterner<>();
 
   /**
    * Содержимое описания для каждого языка
    */
-  Map<String, String> content;
+  Set<Entry> content;
 
-  public MultiLanguageString(Map<String, String> source) {
-    Map<String, String> newContent = new HashMap<>();
+  private MultiLanguageString(@NonNull Map<String, String> source) {
+    Set<Entry> newContent = new HashSet<>();
     source.forEach(
-      (langKey, text) -> newContent.put(stringInterner.intern(langKey), text));
-    content = newContent;
+      (langKey, text) -> newContent.add(Entry.create(langKey, text)));
+    content = Collections.unmodifiableSet(newContent);
+  }
+
+  private MultiLanguageString(@NonNull String langKey, @NonNull String value) {
+    this(Set.of(Entry.create(langKey, value)));
+  }
+
+  private MultiLanguageString(@NonNull MultiLanguageString first, @NonNull MultiLanguageString second) {
+    var fullContent = new HashSet<>(first.getContent());
+    fullContent.addAll(second.getContent());
+    content = Collections.unmodifiableSet(fullContent);
   }
 
-  public MultiLanguageString(@NonNull MultiLanguageString first, @NonNull MultiLanguageString second) {
-    var fullContent = new HashMap<>(first.getContent());
-    putContent(fullContent, second);
-    content = fullContent;
+  private MultiLanguageString(Set<Entry> content) {
+    this.content = Collections.unmodifiableSet(content);
   }
 
   /**
@@ -69,26 +82,42 @@ public MultiLanguageString(@NonNull MultiLanguageString first, @NonNull MultiLan
    * @param strings Список мультиязычных строк
    * @return Объединенное значение
    */
-  public static MultiLanguageString of(@NonNull List<MultiLanguageString> strings) {
+  public static MultiLanguageString create(@NonNull List<MultiLanguageString> strings) {
     if (strings.isEmpty()) {
       return EMPTY;
     } else if (strings.size() == 1) {
       return strings.get(0);
     } else {
-      Map<String, String> content = new HashMap<>();
-      strings.forEach(string -> putContent(content, string));
-      return new MultiLanguageString(content);
+      Set<Entry> content = new HashSet<>();
+      strings.forEach(string -> content.addAll(string.getContent()));
+      return new MultiLanguageString(content).intern();
     }
   }
 
+  public static MultiLanguageString create(@NonNull Set<Entry> langContent) {
+    return new MultiLanguageString(langContent).intern();
+  }
+
+  public static MultiLanguageString create(@NonNull MultiLanguageString first, @NonNull MultiLanguageString second) {
+    return new MultiLanguageString(first, second).intern();
+  }
+
+  public static MultiLanguageString create(@NonNull String langKey, @NonNull String value) {
+    return new MultiLanguageString(langKey, value).intern();
+  }
+
   /**
    * Возвращает содержимое для указанного языка
    *
    * @param lang Требуемый язык
    * @return Содержимое для указанного языка
    */
   public @NonNull String get(@NonNull String lang) {
-    return content.getOrDefault(lang, "");
+    return content.stream()
+      .filter(entry -> entry.getLangKey().equals(lang))
+      .map(Entry::getValue)
+      .findFirst()
+      .orElse("");
   }
 
   /**
@@ -100,7 +129,7 @@ public static MultiLanguageString of(@NonNull List<MultiLanguageString> strings)
     if (content.isEmpty()) {
       return "";
     }
-    return content.entrySet().iterator().next().getValue();
+    return content.iterator().next().getValue();
   }
 
   /**
@@ -112,8 +141,83 @@ public boolean isEmpty() {
     return this == EMPTY;
   }
 
-  private static void putContent(Map<String, String> destination, MultiLanguageString source) {
-    source.getContent().forEach(
-      (langKey, text) -> destination.put(stringInterner.intern(langKey), text));
+  @Override
+  public int compareTo(@Nullable MultiLanguageString multiLanguageString) {
+    if (multiLanguageString == null) {
+      return 1;
+    }
+
+    if (this.equals(multiLanguageString)) {
+      return 0;
+    }
+
+    int compareResult = content.size() - multiLanguageString.content.size();
+    if (compareResult != 0) {
+      return compareResult;
+    }
+
+    // количество равно, но списки не равны
+    // попробуем оставить в списках только уникальные элементы
+    // если останется больше 0 (а странно будет, если не так), то сравним по первому элементу
+    var left = new HashSet<>(content);
+    var right = new HashSet<>(multiLanguageString.content);
+    left.removeAll(right);
+    right.removeAll(left);
+    if (left.isEmpty() && right.isEmpty()) {
+      return 0; // хз как это получилось
+    } else if (left.isEmpty()) {
+      return -1;
+    } else if (right.isEmpty()) {
+      return 1;
+    } else {
+      var leftOne = left.iterator().next();
+      var rightOne = right.iterator().next();
+      return leftOne.compareTo(rightOne);
+    }
+  }
+
+  private MultiLanguageString intern() {
+    return interner.intern(this);
+  }
+
+  @EqualsAndHashCode
+  public static class Entry implements Comparable<Entry> {
+    @Getter
+    private final String langKey;
+    @Getter
+    private final String value;
+    private static final StringInterner stringInterner = new StringInterner();
+    private static final GenericInterner<Entry> interner = new GenericInterner<>();
+
+    private Entry(String langKey, String value) {
+      this.langKey = stringInterner.intern(langKey);
+      this.value = value;
+    }
+
+    public static Entry create(String langKey, String value) {
+      return new Entry(langKey, value).intern();
+    }
+
+    @Override
+    public int compareTo(@Nullable Entry entry) {
+      if (entry == null) {
+        return 1;
+      }
+
+      if (this.equals(entry)) {
+        return 0;
+      }
+
+      int compareResult = langKey.compareTo(entry.langKey);
+      if (compareResult != 0) {
+        return compareResult;
+      }
+
+      return value.compareTo(entry.value);
+    }
+
+    private Entry intern() {
+      return interner.intern(this);
+    }
   }
 }