parameters.h

Go to the documentation of this file.

/*
  Copyright (C) 2018-2024 by the authors of the World Builder code.

  This file is part of the World Builder.

   This program 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 2 of the License, or
   (at your option) any later version.

   This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#ifndef WORLD_BUILDER_PARAMETERS_H
#define WORLD_BUILDER_PARAMETERS_H

#include <map>
#include <memory>
#include <vector>

#include "rapidjson/schema.h"
#include "world_builder/point.h"
#include "world_builder/types/unsigned_int.h"

namespace WorldBuilder
{
  namespace Types
  {
    class Interface;
    template<unsigned int dim>
    class Point;
    class Double;
    class String;
    class Segment;
    class Array;
    class Bool;
    class UnsignedInt;
    class Int;
  } // namespace Types

  namespace Features
  {
    class Interface;
  } // namespace Features

  namespace CoordinateSystems
  {
    class Interface;
  } // namespace CoordinateSystems

  namespace GravityModel
  {
    class Interface;
  } // namespace GravityModel

  class World;

  class Parameters
  {
    public:
      Parameters(World &world);

      ~Parameters();

      void initialize(std::string &filename, bool has_output_dir = false, const std::string &output_dir = "");

      template<class T>
      T get(const std::string &name);

      template<class T>
      std::vector<T> get_vector(const std::string &name);

      std::vector<std::vector<double>> get_vector_or_double(const std::string &name);

      std::pair<std::vector<double>,std::vector<double>>
                                                      get(const std::string &name,
                                                          const std::vector<Point<2> > &addition_points = {});

      std::pair<std::vector<double>,std::vector<double>> get_value_at_array(const std::string &name);

      template<class T, class A, class B, class C, class D>
      std::vector<T> get_vector(const std::string &name, std::vector<std::shared_ptr<A> > &, std::vector<std::shared_ptr<B> > &, std::vector<std::shared_ptr<C> > &, std::vector<std::shared_ptr<D> > &);

      template<class T>
      std::unique_ptr<T> get_unique_pointer(const std::string &name);

      template<class T>
      bool
      get_unique_pointers(const std::string &name, std::vector<std::unique_ptr<T> > &vector);

      template<class T>
      bool
      get_shared_pointers(const std::string &name, std::vector<std::shared_ptr<T> > & /*vector*/);

      bool
      check_entry(const std::string &name) const;

      void declare_entry(const std::string &name,
                         const Types::Interface &type,
                         const std::string &documentation);


      void enter_subsection(const std::string &name);

      void leave_subsection();

      void
      declare_model_entries(const std::string &model_group_name,
                            const std::string &parent_name,
                            const std::map<std::string, void ( *)(Parameters &,const std::string &)> &declare_map,
                            const std::vector<std::string> &required_entries = {},
                            const std::vector<std::tuple<std::string,const WorldBuilder::Types::Interface &, std::string> > &extra_declarations = {});


      World &world;

      const std::string path_separator = ".";

      std::vector<std::string> path;

      rapidjson::Document declarations;
      rapidjson::Document parameters;




      std::vector<std::unique_ptr<WorldBuilder::Features::Interface> > features;

      std::unique_ptr<WorldBuilder::CoordinateSystems::Interface> coordinate_system;

      std::unique_ptr<WorldBuilder::GravityModel::Interface> gravity_model;

      std::string get_full_json_path(size_t max_size = std::numeric_limits<size_t>::max()) const;

      std::string get_full_json_schema_path() const;

      //std::string get_full_path() const;

      //std::string get_full_path_without_arrays() const;

    private:


      size_t path_level;

      std::string get_relative_path() const;

      std::string get_relative_path_without_arrays() const;
  };
} // namespace WorldBuilder
#endif