variant_registry.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2014-09-22
 * Last modified : 2016-10-31
 *
 * Copyright (C) 2014-2016 Francois Mauger <mauger@lpccaen.in2p3.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 * Description:
 *
 *   A registry of configuration variants and associated parameters.
 *
 */

#ifndef DATATOOLS_CONFIGURATION_VARIANT_REGISTRY_H
#define DATATOOLS_CONFIGURATION_VARIANT_REGISTRY_H

// Standard library:
#include <string>
#include <map>
#include <vector>
#include <memory>

// This project (Bayeux/datatools):
#include <datatools/configuration/utils.h>
#include <datatools/enriched_base.h>
#include <datatools/configuration/variant_dependency_model.h>

namespace datatools {

  namespace configuration {

    // Forward declaration:
    class variant_registry_manager;
    class variant_record;
    class variant_repository;

    class variant_registry : public datatools::enriched_base
    {
    public:

      typedef std::map<std::string, variant_record> record_dict_type;

      static const std::string & default_top_variant_name();

      virtual bool is_name_valid(const std::string & name_) const;

      variant_registry();

      virtual ~variant_registry();

      bool has_top_variant_name() const;

      const std::string & get_top_variant_name() const;

      record_dict_type & grab_records();

      const record_dict_type & get_records() const;

      bool is_mounted() const;

      const std::string & get_mounting_name() const;

      bool has_parent_repository() const;

      void set_parent_repository(const variant_repository &, const std::string & mounting_name_);

      void reset_parent_repository();

      const variant_repository & get_parent_repository() const;

      bool is_initialized() const;

      void initialize_from(const variant_registry_manager & mgr_,
                           const std::string & top_variant_ = "",
                           const std::string & name_ = "",
                           const std::string & display_name_ = "",
                           const std::string & terse_description_ = "");

      void reset();

      variant_record & add_record(const std::string & record_path_);

      bool has_variant_record(const std::string & record_path_) const;

      variant_record & grab_variant_record(const std::string & record_path_);

      bool parameter_exists(const std::string & variant_path_) const;

      bool variant_exists(const std::string & variant_path_) const;

      bool is_active_variant(const std::string & variant_path_) const;

      const variant_record & get_variant_record(const std::string & record_path_) const;

      bool has_parameter_record(const std::string & record_path_) const;

      bool has_parameter_record_value_group(const std::string & param_group_path_) const;

      variant_record & grab_parameter_record(const std::string & record_path_);

      const variant_record & get_parameter_record(const std::string & record_path_) const;

      const variant_record & get_top_variant_record() const;

      bool has_dependency_model() const;

      const variant_dependency_model & get_dependency_model() const;

      void load_local_dependency_model(const datatools::properties & ldm_config_);

      virtual void tree_dump(std::ostream & out_ = std::clog,
                             const std::string & title_ = "",
                             const std::string & inden_ = "",
                             bool inherit_ = false) const;

      enum list_flags {
        LIST_ACTIVE_ONLY   = datatools::bit_mask::bit00,
        LIST_NO_SET        = datatools::bit_mask::bit01,
        LIST_NO_UNSET      = datatools::bit_mask::bit02,
        LIST_CLEAR         = datatools::bit_mask::bit03,
        LIST_NO_PARAMETERS = datatools::bit_mask::bit04,
        LIST_NO_VARIANTS   = datatools::bit_mask::bit05,
        LIST_RANKED        = datatools::bit_mask::bit06
      };

      void list_of_ranked_parameters(std::vector<std::string> & paths_) const;

      void list_of_ranked_records(std::vector<std::string> & paths_,
                                  uint32_t flags_ = 0) const;

      void list_of_parameters(std::vector<std::string> &_paths_,
                              uint32_t flags_ = 0) const;

      void list_of_unset_parameters(std::vector<std::string> & unset_paths_) const;

      void build_recursive_list_of_ranked_records(const variant_record & record_,
                                                  std::vector<std::string> & ranked_) const;

      bool is_accomplished() const;

      void update();

    private:

      void _build_parameter_records_from_variant_(const variant_model & varmod_,
                                                  variant_record * parent_variant_record_);

      void _build_variant_records_from_parameter_(const parameter_model & varmod_,
                                                  variant_record * parent_param_record_);

    private:

      // Management:
      bool             _initialized_ = false; 

      // Configuration:
      std::string      _top_variant_name_;    

      // Internal data:
      record_dict_type _records_;             
      const variant_repository * _parent_repository_ = nullptr;     
      std::string                _mounting_name_;                   
      std::unique_ptr<variant_dependency_model> _dependency_model_; 

    };

  } // end of namespace configuration

} // end of namespace datatools

#endif // DATATOOLS_CONFIGURATION_VARIANT_REGISTRY_H

// Local Variables: --
// mode: c++ --
// c-file-style: "gnu" --
// tab-width: 2 --
// End: --