variant_repository.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2014-09-22
 * Last modified : 2016-11-04
 *
 * 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 repository for variant registries.
 *
 */

#ifndef DATATOOLS_CONFIGURATION_VARIANT_REPOSITORY_H
#define DATATOOLS_CONFIGURATION_VARIANT_REPOSITORY_H

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

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

namespace datatools {

  namespace configuration {

    class variant_registry;
    class variant_registry_manager;
    class variant_reporting;
    class variant_record;

    class variant_repository : public datatools::enriched_base
    {
    public:

      static bool parse_variant_path(const std::string & variant_full_path_,
                                     std::string & registry_name_,
                                     std::string & variant_path_,
                                     bool & reversed_);

      struct registry_entry
      {
      public:

        registry_entry(variant_repository &);

        ~registry_entry();

        void set_name(const std::string &);

        const std::string & get_name() const;

        const variant_repository & get_parent_repository() const;

        const variant_registry & get_registry() const;

        variant_registry & grab_registry();

        void reset();

        bool is_external() const;

        bool is_embedded() const;

        bool is_valid() const;

        void set_external_registry(variant_registry &);

        void reset_external_registry();

        void set_rank(int);

        int  get_rank() const;

        bool has_rank() const;

        bool is_sealed() const;

        void seal();

      private:

        std::string                         _name_; 
        variant_repository *                _parent_repository_ = nullptr; 
        int                                 _rank_ = -1;         
        std::shared_ptr<variant_registry_manager> _embedded_manager_; 
        std::shared_ptr<variant_registry>   _embedded_registry_; 
        variant_registry                  * _external_registry_ = nullptr; 
        bool _last_active_ = false; 
        bool _sealed_ = false; 

        friend class variant_repository;

      };

      typedef std::map<std::string, registry_entry> registry_dict_type;
      typedef std::map<int, std::string> ranked_dict_type;

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

      variant_repository();

      ~variant_repository();

      bool has_organization() const;

      const std::string & get_organization() const;

      void set_organization(const std::string &);

      bool has_application() const;

      const std::string & get_application() const;

      void set_application(const std::string &);

      void initialize(const datatools::properties & config_);

      void load_registries(const datatools::properties & config_);

      void load_global_dependency_model(const datatools::properties & gdm_config_);

      void initialize_simple();

      void reset();

      bool is_initialized() const;

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

      unsigned int get_number_of_registries() const;

      void list_of_registry_keys(std::set<std::string> & keys_) const;

      bool has_registry(const std::string & registry_name_) const;

      const variant_registry & get_registry(const std::string & registry_name_) const;

      variant_registry & grab_registry(const std::string & registry_name_);

      const registry_dict_type & get_registries() const;

      registry_dict_type & grab_registries();

      bool rank_is_used(int rank_) const;

      void registration_embedded(const std::string & registry_manager_config_,
                                 const std::string & top_variant_name_ = "",
                                 const std::string & registry_name_ = "",
                                 const std::string & registry_display_name_ = "",
                                 const std::string & registry_terse_description_ = "",
                                 int registry_rank_ = -1,
                                 const datatools::logger::priority registry_logging_ = datatools::logger::PRIO_UNDEFINED);

      void registration_external(variant_registry & external_registry_,
                                 const std::string & registry_name_ = "",
                                 int rank_ = -1);

      void unregistration(const std::string & registry_name_);

      void build_ordered_registry_keys(std::vector<std::string> & keys_) const;

      bool is_ranked(const std::string & registry_name_) const;

      int get_rank(const std::string & registry_name_) const;

      bool is_active_registry(const std::string & registry_key_) const;

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

      void clear_registries();

      void external_registries_unregistration();

      bool is_accomplished() const;

      void set_requested_lock(bool rl_);

      bool is_requested_lock() const;

      bool is_locked() const;

      void lock();

      void unlock();

      bool has_variant(const std::string & registry_key_,
                       const std::string & variant_path_) const;

      bool has_variant_parameter(const std::string & registry_key_,
                                 const std::string & variant_parameter_path_) const;

      bool has_dependency_model() const;

      const variant_dependency_model & get_dependency_model() const;

      enum rst_flags {
        PRINT_RST_NO_TITLE = datatools::bit_mask::bit00
      };

      void print_rst(std::ostream & out_, uint32_t flags_ = 0) const;

      void system_export(uint32_t flags_ = 0);

      void system_discard() const;

      bool has_reporting() const;

      void set_reporting(variant_reporting &);

      void reset_reporting();

      variant_reporting & grab_reporting();

      void update();

      class importer
      {
      public:
        enum init_flags {
          IMPORT_DEBUG   = datatools::bit_mask::bit00,
          IMPORT_NOCLEAR = datatools::bit_mask::bit01,
          IMPORT_DONT_IGNORE_UNKNOWN_REGISTRY = datatools::bit_mask::bit02,
          IMPORT_DONT_IGNORE_UNKNOWN_ORGAPP = datatools::bit_mask::bit03
        };
        importer(const datatools::properties & config_, uint32_t flags_ = 0);
        void operator()(variant_repository & vrep_);
      protected:
        void _process_registry(variant_registry & vreg_);
        void _process_record(variant_record & vrec_);
      private:
        datatools::logger::priority   _logging_ = datatools::logger::PRIO_FATAL;
        bool                          _noclear_ = false;
        bool                          _dont_ignore_unknown_registries_ = false;
        bool                          _dont_ignore_unknown_orgapp_ = false;
        const datatools::properties & _config_;
        std::vector<std::string>      _settings_;
        std::string                   _current_registry_name_;
        std::string                   _current_setting_;
      };

      class exporter
      {
      public:
        enum init_flags {
          EXPORT_DEBUG    = datatools::bit_mask::bit00,
          EXPORT_NOCLEAR  = datatools::bit_mask::bit01,
          EXPORT_NOORGAPP = datatools::bit_mask::bit02
        };
        exporter(datatools::properties & config_, uint32_t flags_ = 0);
        void set_settings_key(const std::string &);
        void process(const variant_repository & vrep_);
        const std::vector<std::string> & get_settings() const;
        void operator()(const variant_repository & vrep_);
      protected:
        void _process_registry(const variant_registry & vreg_);
        void _process_record(const variant_record & vrec_);
      private:
        datatools::logger::priority _logging_ = datatools::logger::PRIO_FATAL;
        bool                        _noclear_ = false;
        bool                        _noorgapp_ = false;
        datatools::properties &     _config_;   
        std::string                 _settings_key_;
        // Working temporary data:
        std::vector<std::string>    _settings_;
        std::string                 _current_registry_name_;
      };

    protected:

      registry_entry & _add_entry(const std::string & registry_name_, int rank_ = -1);

      void _legacy_load_registries(const datatools::properties & config_);

      void _at_init_();

      void _at_reset_();

      void _compute_ranked_unranked_();

    private:

      // Management:
      bool               _initialized_ = false;  

      // Configuration:
      std::string        _organization_;         
      std::string        _application_;          
      bool               _requested_lock_ = false; 

      // Working data:
      bool               _locked_ = false;       
      registry_dict_type _registries_;           
      ranked_dict_type   _ranked_;               
      std::vector<std::string> _unranked_;       
      std::unique_ptr<variant_dependency_model> _dependency_model_; 
      variant_reporting * _reporting_ = nullptr; 

    };

  } // end of namespace configuration

} // end of namespace datatools

#endif // DATATOOLS_CONFIGURATION_VARIANT_REPOSITORY_H

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