Merge pull request #61 from 1c-syntax/feature/optimizeReadMetadata

Feature/optimize read metadata

Author: nixel2007

build.gradle.kts

@@ -20,8 +20,8 @@ repositories {
 val junitVersion = "5.5.2"
 dependencies {
 
-    implementation("com.fasterxml.jackson.dataformat", "jackson-dataformat-xml", "2.9.4")
-    implementation("com.fasterxml.jackson.module", "jackson-module-parameter-names", "2.9.4")
+    implementation("com.fasterxml.jackson.dataformat", "jackson-dataformat-xml", "2.10.3")
+    implementation("com.fasterxml.jackson.module", "jackson-module-parameter-names", "2.10.3")
 
     // логирование
     implementation("org.slf4j", "slf4j-api", "1.8.0-beta4")

src/main/java/com/github/_1c_syntax/mdclasses/mdo/MDObjectBase.java

@@ -7,6 +7,8 @@
 import com.github._1c_syntax.mdclasses.metadata.additional.ModuleType;
 import lombok.Builder;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
 import lombok.experimental.NonFinal;
 import lombok.experimental.SuperBuilder;
 
@@ -21,15 +23,17 @@
 @NonFinal
 @JsonDeserialize(builder = MDObjectBase.MDObjectBaseBuilderImpl.class)
 @SuperBuilder
+@EqualsAndHashCode(exclude = {"mdoURI", "modulesByType", "forms"})
+@ToString(exclude = {"mdoURI", "modulesByType", "forms"})
 public class MDObjectBase {
 
-  protected String uuid;
-  protected String name;
+  protected final String uuid;
+  protected final String name;
   @Builder.Default
   protected String comment = "";
+
   protected URI mdoURI;
   protected Map<URI, ModuleType> modulesByType;
-
   protected List<Form> forms;
 
   public abstract static class MDObjectBaseBuilder

src/main/java/com/github/_1c_syntax/mdclasses/metadata/Configuration.java

@@ -11,7 +11,6 @@
 import com.github._1c_syntax.mdclasses.metadata.additional.UseMode;
 import com.github._1c_syntax.mdclasses.metadata.utils.Common;
 import com.github._1c_syntax.mdclasses.metadata.utils.MDOUtils;
-import lombok.SneakyThrows;
 import lombok.Value;
 import lombok.extern.slf4j.Slf4j;
 
@@ -20,35 +19,36 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 
 @Value
 @Slf4j
 public class Configuration {
 
-  protected String name;
-  protected String uuid;
+  String name;
+  String uuid;
 
-  protected ConfigurationSource configurationSource;
-  protected CompatibilityMode compatibilityMode;
-  protected CompatibilityMode configurationExtensionCompatibilityMode;
-  protected ScriptVariant scriptVariant;
+  ConfigurationSource configurationSource;
+  CompatibilityMode compatibilityMode;
+  CompatibilityMode configurationExtensionCompatibilityMode;
+  ScriptVariant scriptVariant;
 
-  protected String defaultRunMode;
-  protected String defaultLanguage;
-  protected String dataLockControlMode;
-  protected String objectAutonumerationMode;
-  protected UseMode modalityUseMode;
-  protected UseMode synchronousExtensionAndAddInCallUseMode;
-  protected UseMode synchronousPlatformExtensionAndAddInCallUseMode;
+  String defaultRunMode;
+  String defaultLanguage;
+  String dataLockControlMode;
+  String objectAutonumerationMode;
+  UseMode modalityUseMode;
+  UseMode synchronousExtensionAndAddInCallUseMode;
+  UseMode synchronousPlatformExtensionAndAddInCallUseMode;
 
-  protected Map<URI, ModuleType> modulesByType;
-  protected Map<URI, Map<SupportConfiguration, SupportVariant>> modulesBySupport;
-  protected Map<MDOType, Map<String, MDObjectBase>> children;
-  private Path rootPath;
+  Map<URI, ModuleType> modulesByType;
+  Map<URI, Map<SupportConfiguration, SupportVariant>> modulesBySupport;
+  Set<MDObjectBase> children;
+  Path rootPath;
 
   private Configuration() {
     this.configurationSource = ConfigurationSource.EMPTY;
-    this.children = Collections.emptyMap();
+    this.children = Collections.emptySet();
     this.modulesByType = Collections.emptyMap();
     this.modulesBySupport = Collections.emptyMap();
 
@@ -89,7 +89,7 @@ private Configuration(MDOConfiguration configurationXml, ConfigurationSource con
     this.synchronousExtensionAndAddInCallUseMode = configurationXml.getSynchronousExtensionAndAddInCallUseMode();
     this.synchronousPlatformExtensionAndAddInCallUseMode = configurationXml.getSynchronousPlatformExtensionAndAddInCallUseMode();
 
-    this.modulesByType = MDOUtils.getModuleTypesByPath(configurationSource, rootPath);
+    this.modulesByType = Common.getModuleTypesByPath(this);
     this.modulesBySupport = Common.getModuleSupports(this);
   }
 
@@ -110,30 +110,6 @@ public static Configuration create(Path rootPath) {
     return create();
   }
 
-  public MDObjectBase getChild(MDOType type, String childName) {
-    MDObjectBase child = null;
-    Map<String, MDObjectBase> childrenByType = children.get(type);
-    if (childrenByType == null) {
-      childrenByType = getChildren(type);
-    }
-    if (!childrenByType.isEmpty()) {
-      child = childrenByType.get(childName);
-    }
-    return child;
-  }
-
-  @SneakyThrows
-  public Map<String, MDObjectBase> getChildren(MDOType type) {
-    Map<String, MDObjectBase> childrenByType = children.get(type);
-    if (childrenByType == null) {
-      childrenByType = MDOUtils.getChildren(configurationSource, rootPath, type);
-    }
-    if (!childrenByType.isEmpty()) {
-      children.put(type, childrenByType);
-    }
-    return childrenByType;
-  }
-
   public ModuleType getModuleType(URI uri) {
     return modulesByType.getOrDefault(uri, ModuleType.Unknown);
   }

src/main/java/com/github/_1c_syntax/mdclasses/metadata/SupportConfiguration.java

@@ -6,7 +6,7 @@
 @Value
 @AllArgsConstructor
 public class SupportConfiguration {
-  private String name;
-  private String provider;
-  private String version;
+  protected String name;
+  protected String provider;
+  protected String version;
 }

src/main/java/com/github/_1c_syntax/mdclasses/metadata/utils/Common.java

@@ -4,6 +4,7 @@
 import com.github._1c_syntax.mdclasses.metadata.Configuration;
 import com.github._1c_syntax.mdclasses.metadata.SupportConfiguration;
 import com.github._1c_syntax.mdclasses.metadata.additional.ConfigurationSource;
+import com.github._1c_syntax.mdclasses.metadata.additional.ModuleType;
 import com.github._1c_syntax.mdclasses.metadata.additional.SupportVariant;
 import lombok.extern.slf4j.Slf4j;
 
@@ -43,47 +44,54 @@ public static Map<URI, Map<SupportConfiguration, SupportVariant>> getModuleSuppo
       ParseSupportData supportData = new ParseSupportData(fileParentConfiguration.toPath());
       final Map<String, Map<SupportConfiguration, SupportVariant>> supportMap = supportData.getSupportMap();
 
-      configuration.getChildren()
-        .forEach((mdoType, stringMDObjectBaseMap) ->
-          stringMDObjectBaseMap.forEach((name, mdObject) -> {
-            var mdoModuleSupport = getMDObjectSupport(supportMap, mdObject);
-            if (!mdoModuleSupport.isEmpty()) {
-              modulesBySupport.putAll(mdoModuleSupport);
-            }
-            if (mdObject.getForms() != null) {
-              mdObject.getForms().forEach(form -> {
-                var formSupport = getMDObjectSupport(supportMap, form);
-                if (!formSupport.isEmpty()) {
-                  modulesBySupport.putAll(formSupport);
-                }
-              });
-            }
-          })
-        );
+      configuration.getChildren().forEach(mdObject -> {
+        modulesBySupport.putAll(getMDObjectSupport(supportMap, mdObject));
+        if (mdObject.getForms() != null) {
+          mdObject.getForms().forEach(form -> modulesBySupport.putAll(getMDObjectSupport(supportMap, form)));
+        }
+      });
     }
+
     return modulesBySupport;
   }
 
-  private static Map<URI, Map<SupportConfiguration, SupportVariant>> getMDObjectSupport(Map<String, Map<SupportConfiguration, SupportVariant>> supportMap, MDObjectBase mdObject) {
+  private static Map<URI, Map<SupportConfiguration, SupportVariant>> getMDObjectSupport(
+    Map<String, Map<SupportConfiguration, SupportVariant>> supportMap,
+    MDObjectBase mdObject) {
+
     Map<URI, Map<SupportConfiguration, SupportVariant>> modulesBySupport = new HashMap<>();
-    Set<URI> uris = new HashSet<>();
-    if (mdObject.getMdoURI() != null) {
-      uris.add(mdObject.getMdoURI());
-    }
-    if (mdObject.getModulesByType() != null) {
-      mdObject.getModulesByType().forEach((uri, moduleType) -> uris.add(uri));
+    if (mdObject.getUuid() == null || mdObject.getModulesByType() == null) {
+      return modulesBySupport;
     }
 
-    Map<SupportConfiguration, SupportVariant> moduleSupport = Collections.emptyMap();
-    if (mdObject.getUuid() == null) {
-      LOGGER.info("Не удалось найти идентфикатор по объекту " + mdObject);
-    } else {
-      moduleSupport = supportMap.getOrDefault(mdObject.getUuid(), Collections.emptyMap());
-    }
+    Set<URI> uris = new HashSet<>(mdObject.getModulesByType().keySet());
+
+    Map<SupportConfiguration, SupportVariant> moduleSupport =
+      supportMap.getOrDefault(mdObject.getUuid(), Collections.emptyMap());
+
     for (URI uri : uris) {
       modulesBySupport.put(uri, moduleSupport);
     }
     return modulesBySupport;
   }
 
+  public static Map<URI, ModuleType> getModuleTypesByPath(Configuration configuration) {
+    Map<URI, ModuleType> modulesByType = new HashMap<>();
+
+    configuration.getChildren().forEach(mdObject -> {
+        if (mdObject.getModulesByType() != null) {
+          mdObject.getModulesByType().forEach(modulesByType::put);
+        }
+        if (mdObject.getForms() != null) {
+          mdObject.getForms().forEach(form -> {
+            if (form.getModulesByType() != null) {
+              form.getModulesByType().forEach(modulesByType::put);
+            }
+          });
+        }
+      }
+    );
+    return modulesByType;
+  }
+
 }

src/main/java/com/github/_1c_syntax/mdclasses/metadata/utils/MDOUtils.java

@@ -306,14 +306,14 @@ public static MDObjectBase getMDObject(ConfigurationSource configurationSource,
       if (configurationSource == ConfigurationSource.EDT) {
         try {
           mdo = (MDObjectBase) xmlMapper
-            .readValue(mdoPath.toFile(),
+            .readValue(mdoFile,
               Class.forName(MDObjectBase.class.getPackageName() + "." + type.getShortClassName()));
         } catch (IOException | ClassNotFoundException e) {
           LOGGER.error(e.getMessage(), e);
         }
       } else if (configurationSource == ConfigurationSource.DESIGNER) {
         try {
-          MetaDataObject metaDataObject = xmlMapper.readValue(mdoPath.toFile(), MetaDataObject.class);
+          MetaDataObject metaDataObject = xmlMapper.readValue(mdoFile, MetaDataObject.class);
           mdo = metaDataObject.getPropertyByType(type);
         } catch (IOException e) {
           LOGGER.error(e.getMessage(), e);
@@ -381,6 +381,7 @@ public static Map<URI, ModuleType> getModuleTypesByPath(ConfigurationSource conf
       }
 
       getMDOFilesInFolder(configurationSource, folder)
+        .parallelStream()
         .forEach(mdoPath -> {
             modulesByType.putAll(
               getModuleTypesByMDOPath(configurationSource, mdoPath, folder, mdoType));
@@ -443,11 +444,11 @@ private static Map<URI, ModuleType> getCommandsMDOModuleTypes(ConfigurationSourc
    * Children
    */
 
-  public static Map<String, MDObjectBase> getChildren(ConfigurationSource configurationSource,
-                                                      Path rootPath,
-                                                      MDOType type) {
+  public static Set<MDObjectBase> getChildren(ConfigurationSource configurationSource,
+                                              Path rootPath,
+                                              MDOType type) {
 
-    Map<String, MDObjectBase> children = new HashMap<>();
+    Set<MDObjectBase> children = new HashSet<>();
     if (configurationSource == ConfigurationSource.EMPTY) {
       return children;
     }
@@ -458,22 +459,23 @@ public static Map<String, MDObjectBase> getChildren(ConfigurationSource configur
     }
 
     getChildrenNamesInFolder(configurationSource, folder)
+      .parallelStream()
       .forEach(childName -> {
         MDObjectBase child = getMDObject(configurationSource, rootPath, type, childName);
         if (child != null) {
-          children.put(childName, child);
+          children.add(child);
         }
       });
 
     return children;
   }
 
-  public static Map<MDOType, Map<String, MDObjectBase>> getAllChildren(ConfigurationSource configurationSource,
-                                                                       Path rootPath,
-                                                                       boolean includeConfiguration) {
+  public static Set<MDObjectBase> getAllChildren(ConfigurationSource configurationSource,
+                                                 Path rootPath,
+                                                 boolean includeConfiguration) {
 
 
-    Map<MDOType, Map<String, MDObjectBase>> allChildren = new HashMap<>();
+    Set<MDObjectBase> allChildren = new HashSet<>();
     if (configurationSource == ConfigurationSource.EMPTY) {
       return allChildren;
     }
@@ -482,7 +484,7 @@ public static Map<MDOType, Map<String, MDObjectBase>> getAllChildren(Configurati
       if (!includeConfiguration && type == MDOType.CONFIGURATION) {
         continue;
       }
-      allChildren.put(type, getChildren(configurationSource, rootPath, type));
+      allChildren.addAll(getChildren(configurationSource, rootPath, type));
     }
     return allChildren;
   }
@@ -563,8 +565,10 @@ private List<Path> getMDOFilesInFolder(ConfigurationSource configurationSource,
       if (configurationSource == ConfigurationSource.EDT) {
         maxDepth = 2;
       }
+
       try (Stream<Path> files = Files.walk(folder, maxDepth)) {
         childrenNames = files
+          .parallel()
           .filter(f -> f.toString().endsWith(extension.get()))
           .filter(f -> !FilenameUtils.getBaseName(f.toString()).equals("ConfigDumpInfo"))
           .collect(Collectors.toList());

src/main/java/com/github/_1c_syntax/mdclasses/metadata/utils/ParseSupportData.java

@@ -6,11 +6,8 @@
 
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
-import java.io.IOException;
 import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Scanner;
@@ -49,9 +46,9 @@ private void read() throws FileNotFoundException {
     String[] dataStrings;
     var fileInputStream = new FileInputStream(pathToBinFile.toFile());
     var scanner = new Scanner(fileInputStream, StandardCharsets.UTF_8);
-      dataStrings = scanner.findAll(patternSplit)
-        .map(matchResult -> matchResult.group(1))
-        .toArray(String[]::new);
+    dataStrings = scanner.findAll(patternSplit)
+      .map(matchResult -> matchResult.group(1))
+      .toArray(String[]::new);
 
     var countConfiguration = Integer.parseInt(dataStrings[POINT_COUNT_CONFIGURATION]);
     LOGGER.debug("Найдено конфигураций: {}", countConfiguration);
@@ -81,11 +78,7 @@ private void read() throws FileNotFoundException {
         var guidObject = dataStrings[currentObjectPoint + 2];
         var supportVariant = getSupportVariantByInt(support);
 
-        Map<SupportConfiguration, SupportVariant> map = supportMap.get(guidObject);
-        if (map == null) {
-          map = new HashMap<>();
-          supportMap.put(guidObject, map);
-        }
+        Map<SupportConfiguration, SupportVariant> map = supportMap.computeIfAbsent(guidObject, k -> new HashMap<>());
         map.put(supportConfiguration, supportVariant);
       }