JSONFileReader.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "GeneralUserObject.h"
 
class JSONFileReader : public GeneralUserObject
{
public:
  static InputParameters validParams();
 
  JSONFileReader(const InputParameters & parameters);
 
  virtual void initialize() override {}
 
  virtual void finalize() override {}
 
  virtual void execute() override { read(_filename); }
 
 
  template <typename T>
  void getValue(const std::string & value_name, T & value) const
  {
    if (!_root.contains(value_name))
      mooseError("Attempted to get '",
                 value_name,
                 "' but the JSON file does not contain this key directly at the root level");
    value = _root[value_name].get<T>();
  }
 
  template <typename T>
  void getValue(const std::vector<std::string> & value_keys, T & value) const
  {
    if (!value_keys.size())
      mooseError("There should be at least one key to retrieve a value from the JSON");
 
    // traverse the JSON tree
    auto * current_node = &_root[value_keys[0]];
    for (const auto key_index : index_range(value_keys))
    {
      if (key_index == value_keys.size() - 1)
      {
        value = current_node->template get<T>();
        break;
      }
      current_node = &(*current_node)[value_keys[key_index + 1]];
    }
  }
 
  template <typename T>
  void getVector(const std::string & vector_name, std::vector<T> & vector_to_fill) const
  {
    if (!_root.contains(vector_name))
      mooseError("Attempted to get '",
                 vector_name,
                 "' but the JSON file does not contain this key at the root level");
    vector_to_fill.clear();
    for (const auto & item : _root[vector_name])
      vector_to_fill.push_back(item.get<T>());
  }
  template <typename T>
  void getVector(const std::vector<std::string> & vector_keys,
                 std::vector<T> & vector_to_fill) const
  {
    if (!vector_keys.size())
      mooseError("There should be at least one key to retrieve a value from the JSON");
 
    // traverse the JSON tree
    auto * current_node = &_root[vector_keys[0]];
    for (const auto key_index : index_range(vector_keys))
    {
      if (key_index == vector_keys.size() - 1)
      {
        if (!current_node->is_array())
          mooseError("Cannot retrieve a vector from JSON node",
                     nlohmann::to_string(*current_node),
                     "obtained with last key",
                     vector_keys[key_index]);
        vector_to_fill.clear();
        for (const auto & item : *current_node)
          vector_to_fill.push_back(item.template get<T>());
        return;
      }
      if (current_node->is_array())
        mooseError("Cannot obtain nested JSON item with key",
                   vector_keys[key_index + 1],
                   "because the current item is an array:",
                   nlohmann::to_string(*current_node));
      current_node = &(*current_node)[vector_keys[key_index + 1]];
    }
  }
 
private:
  void read(const FileName & filename);
 
  const FileName & _filename;
  nlohmann::json _root;
};