Generalization of ValidationState

CesiumGS · Sep 26, 2023 · e427da1 · e427da1
1 parent bdc6544
commit e427da1
Show file tree

Hide file tree

Showing 11 changed files with 173 additions and 188 deletions.
diff --git a/src/ValidatorMain.ts b/src/ValidatorMain.ts
@@ -1,19 +1,19 @@
 import path from "path";
 
 import { defined } from "3d-tiles-tools";
+import { defaultValue } from "3d-tiles-tools";
+import { Iterables } from "3d-tiles-tools";
+import { TileImplicitTiling } from "3d-tiles-tools";
+import { Schema } from "3d-tiles-tools";
+
 import { readJsonUnchecked } from "./base/readJsonUnchecked";
 import { globMatcher } from "./base/globMatcher";
 import { writeUnchecked } from "./base/writeUnchecked";
-import { Iterables } from "3d-tiles-tools";
 
-import { ValidationState } from "./validation/ValidationState";
 import { Validators } from "./validation/Validators";
 import { ValidationResult } from "./validation/ValidationResult";
 import { ValidationOptions } from "./validation/ValidationOptions";
-
-import { TileImplicitTiling } from "3d-tiles-tools";
-import { Schema } from "3d-tiles-tools";
-import { defaultValue } from "3d-tiles-tools";
+import { ValidatedElement } from "./validation/ValidatedElement";
 
 /**
  * A class summarizing the command-line functions of the validator.
@@ -189,14 +189,14 @@ export class ValidatorMain {
 
   static async validateSubtreeFile(
     fileName: string,
-    validationState: ValidationState,
+    schemaState: ValidatedElement<Schema>,
     implicitTiling: TileImplicitTiling | undefined,
     reportFileName: string | undefined
   ): Promise<ValidationResult> {
     console.log("Validating subtree " + fileName);
     const validationResult = await Validators.validateSubtreeFile(
       fileName,
-      validationState,
+      schemaState,
       implicitTiling
     );
     if (defined(reportFileName)) {
@@ -276,36 +276,25 @@ export class ValidatorMain {
     fileName: string,
     reportFileName: string | undefined
   ): Promise<void> {
-    let implicitTiling = undefined;
-    let validationState: ValidationState = {
-      hasSchemaDefinition: false,
-      hasGroupsDefinition: false,
+    // The schema for the subtrees in the specs directory
+    const specSchema: Schema = await readJsonUnchecked(
+      "specs/data/schemas/validSchema.json"
+    );
+    const specSchemaState: ValidatedElement<Schema> = {
+      wasPresent: true,
+      validatedElement: specSchema,
     };
 
     // The `TileImplicitTiling` object that defines the
     // structure of subtrees in the specs directory
     const specImplicitTiling = await readJsonUnchecked(
       "specs/data/subtrees/validSubtreeImplicitTiling.json.input"
     );
-    implicitTiling = specImplicitTiling;
-
-    // The `ValidationState` object that contains the
-    // schema for the subtrees in the specs directory
-    const specSchema: Schema = await readJsonUnchecked(
-      "specs/data/schemas/validSchema.json"
-    );
-    const specValidationState: ValidationState = {
-      hasSchemaDefinition: true,
-      validatedSchema: specSchema,
-      hasGroupsDefinition: false,
-      validatedGroups: undefined,
-    };
-    validationState = specValidationState;
 
     await ValidatorMain.validateSubtreeFile(
       fileName,
-      validationState,
-      implicitTiling,
+      specSchemaState,
+      specImplicitTiling,
       reportFileName
     );
   }

diff --git a/src/validation/ContentValidator.ts b/src/validation/ContentValidator.ts
@@ -97,8 +97,10 @@ export class ContentValidator {
       ) {
         result = false;
       } else {
+        const groupsState = validationState.groupsState;
+
         // When a group is given, the tileset MUST define groups
-        if (!validationState.hasGroupsDefinition) {
+        if (!groupsState.wasPresent) {
           const message =
             `Tile content has a group index ${group}, ` +
             `but the containing tileset does not define groups`;
@@ -108,12 +110,12 @@ export class ContentValidator {
           );
           context.addIssue(issue);
           result = false;
-        } else if (defined(validationState.validatedGroups)) {
-          if (group >= validationState.validatedGroups.length) {
+        } else if (defined(groupsState.validatedElement)) {
+          if (group >= groupsState.validatedElement.length) {
             const message =
               `Tile content has a group index ${group}, ` +
               `but the containing tileset only contains ` +
-              `${validationState.validatedGroups.length} groups`;
+              `${groupsState.validatedElement.length} groups`;
             const issue = StructureValidationIssues.IDENTIFIER_NOT_FOUND(
               groupPath,
               message
@@ -163,7 +165,8 @@ export class ContentValidator {
     const metadata = content.metadata;
     const metadataPath = contentPath + "/metadata";
     if (defined(metadata)) {
-      if (!validationState.hasSchemaDefinition) {
+      const schemaState = validationState.schemaState;
+      if (!schemaState.wasPresent) {
         // If there is metadata, then there must be a schema definition
         const message =
           "The content defines 'metadata' but the tileset does not have a schema";
@@ -173,13 +176,13 @@ export class ContentValidator {
         );
         context.addIssue(issue);
         result = false;
-      } else if (defined(validationState.validatedSchema)) {
+      } else if (defined(schemaState.validatedElement)) {
         if (
           !MetadataEntityValidator.validateMetadataEntity(
             metadataPath,
             "content.metadata",
             metadata,
-            validationState.validatedSchema,
+            schemaState.validatedElement,
             context
           )
         ) {

diff --git a/src/validation/StatisticsValidator.ts b/src/validation/StatisticsValidator.ts
@@ -1,15 +1,15 @@
 import { defined } from "3d-tiles-tools";
+import { Schema } from "3d-tiles-tools";
+import { Statistics } from "3d-tiles-tools";
 
 import { ValidationContext } from "./ValidationContext";
 import { BasicValidator } from "./BasicValidator";
-import { ValidationState } from "./ValidationState";
 import { RootPropertyValidator } from "./RootPropertyValidator";
 import { ExtendedObjectsValidators } from "./ExtendedObjectsValidators";
-
-import { Statistics } from "3d-tiles-tools";
+import { StatisticsClassValidator } from "./StatisticsClassValidator";
+import { ValidatedElement } from "./ValidatedElement";
 
 import { StructureValidationIssues } from "../issues/StructureValidationIssues";
-import { StatisticsClassValidator } from "./StatisticsClassValidator";
 
 /**
  * A class for validations related to `statistics` objects.
@@ -23,14 +23,14 @@ export class StatisticsValidator {
    *
    * @param path - The path for `ValidationIssue` instances
    * @param statistics - The object to validate
-   * @param validationState - The `ValidationState`.
+   * @param schemaState - The state of the schema validation.
    * @param context - The `ValidationContext` that any issues will be added to
    * @returns Whether the object was valid
    */
   static validateStatistics(
     path: string,
     statistics: Statistics,
-    validationState: ValidationState,
+    schemaState: ValidatedElement<Schema>,
     context: ValidationContext
   ): boolean {
     // Make sure that the given value is an object
@@ -96,7 +96,7 @@ export class StatisticsValidator {
         }
 
         // If there are classes, then there must be a schema
-        if (!validationState.hasSchemaDefinition) {
+        if (!schemaState.wasPresent) {
           const message =
             "The tileset defines 'statistics.classes' but does not have a schema";
           const issue = StructureValidationIssues.REQUIRED_VALUE_NOT_FOUND(
@@ -105,15 +105,15 @@ export class StatisticsValidator {
           );
           context.addIssue(issue);
           result = false;
-        } else if (defined(validationState.validatedSchema)) {
+        } else if (defined(schemaState.validatedElement)) {
           // Validate all entries of the classes dictionary
           for (const className of Object.keys(classes)) {
             const statisticsClass = classes[className];
             if (
               !StatisticsClassValidator.validateStatisticsClass(
                 statisticsClass,
                 className,
-                validationState.validatedSchema,
+                schemaState.validatedElement,
                 context
               )
             ) {