ArcaNetReader.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ArcaNetReader.h                                             (C) 2000-2026 */
/*                                                                           */
/* Lecteur de fichiers ArcaNet.                                              */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_COMMON_ARCANETREADER_H
#define ARCCORE_COMMON_ARCANETREADER_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/base/String.h"
#include "arccore/base/StringBuilder.h"
 
#include "arccore/common/Array.h"
#include "arccore/common/CommonGlobal.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*
 * Example of ArcaNet file (RC2) :
{
  "versions": {
    "_": 0,
    "arcane": 0,
    "arccher": 0
  },
 
  // Coucou
 
  "general": {
    "_": {
      "name": "Common"
    },
    "arcane": {
      "dataset": "./dataset.arc",
      "options": {
        "//meshes/mesh/filename": "aaa.msh",
        "T": 4
      }
    },
    "arccher": {
      "mpi": 4
    }
  },
 
  "commons": {
    "4procs": {
      "_": {
        "name": "4 Procs"
      },
      "arccher": {
        "mpi": 4
      }
    },
    "4threads": {
      "_": {
        "name": "4 Threads"
      },
      "arcane": {
        "options": {
          "S": 4
        }
      }
    },
    "16mpithreads": {
      "_": {
        "name": "16 Hybrid",
        "depend_a": ["4procs", "4threads"]
      }
    }
  },
 
  "variations": {
    "nb_iterations": {
      "10": {
        "_": {
          "name": "10 itérations"
        },
        "arcane": {
          "options": {
            "MaxIteration": 10
          }
        }
      },
      "20": {
        "_": {
          "name": "20 itérations"
        },
        "arcane": {
          "options": {
            "MaxIteration": 20
          }
        }
      },
      "30": {
        "_": {
          "name": "30 itérations"
        },
        "arcane": {
          "options": {
            "MaxIteration": 30
          }
        }
      }
    }
  },
 
  "cases": {
    // Symbole réservé pour le nom du cas : ":", "=", "~"
 
    // Comment appeler "case1" :
    // - "case1" -> ok
    "case1": {
      "_": {
        "name": "Cas 1",
        // Symbole réservé pour les éléments depend_a/depend_b : "=", "!", "+"
        "depend_a": ["4procs", "nb_iterations=10"]
      },
 
      // Symbole réservé pour le nom du programme : ":", "=", "~"
      "arcane": {
        "options": {
          "//meshes/mesh/filename": "aaa.msh",
          "T": 4
        }
      },
 
      "arccher": {
        "mpi": 2
      }
    },
 
    // Comment appeler "case2" :
    // - "case2" -> erreur
    // - "case2:nb_iterations=10" -> ok
    // - "case2:nb_iterations=20" -> erreur
    // - "case2~init:nb_iterations=10" -> ok
    // - "case2~init:nb_iterations=20" -> erreur
    "case2": {
      "_": {
        "name": "Cas 2",
        "depend_b": ["16mpithreads"],
        "depend_a": ["nb_iterations!20"]
      },
      "arcane": {
        "options": {
          "//meshes/mesh/filename": "bbb.msh",
          "T": 8
        }
      },
      "arcane~init": {
        "options": {
          "//meshes/mesh/filename": "bbb.msh",
          "T": 16
        }
      }
    },
    // Comment appeler "case3" :
    // - "case3" -> erreur
    // - "case3:nb_iterations=10" -> ok
    // - "case3:nb_iterations=20" -> ok
    // - "case3:nb_iterations=30" -> erreur
    "case3": {
      "_": {
        "name": "Cas 3",
        "depend_a": ["4procs", "nb_iterations+10+20"]
      },
 
      "arcane": {
        "options": {
          "//meshes/mesh/filename": "ccc.msh",
          "T": 4
        }
      },
 
      "arccher": {
        "mpi": 2
      }
    },
  }
}
 */

class ARCCORE_COMMON_EXPORT ArcaNetReader
{
 public:

  ArcaNetReader(const JSONValue& root);
 
 public:

  void init(const String& case_and_variations_values, const String& prog_name);

  void read();

  ArrayView<JSONValue> jsonValues() { return m_values; }

  JSONValue extractFilePart(const JSONValue& config_part);

  JSONValue extractProgPart(const JSONValue& config_part);

  JSONValue extractPart(const String& part_name, const JSONValue& config_part);

  bool computePath() const { return m_build_path; }

  String path() const { return m_path; }

  String configPartName() { return m_prog_custom_part_name.empty() ? m_prog_part_name : m_prog_custom_part_name; }
 
 private:
 
  void _readDependPart(const JSONValue& depend_part);
  void _readConfigPart(const JSONValue& config_part, const String& node_name);
  void _addElemInPath(const String& elem);
  void _readFileBeforePart(const JSONValue& config_part);
  void _readFileAfterPart(const JSONValue& config_part);
  void _readArcanePart(const JSONValue& config_part);
 
 private:
 
  bool m_build_path = false;
  StringBuilder m_path;
  Integer m_level_path = 0;
  const JSONValue& m_root;
  UniqueArray<String> m_explored;
  UniqueArray<String> m_variations_key_resolved;
  UniqueArray<String> m_variations_value_resolved;
  String m_prog_part_name;
  String m_prog_custom_part_name;
  UniqueArray<JSONValue> m_values;
  String m_case_name;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif