variant_service.h

Go to the documentation of this file.

//
// Copyright (c) 2016 by Francois Mauger <mauger@lpccaen.in2p3.fr>
// Copyright (c) 2016 by Université de Caen
//
// This file is part of Bayeux.
//
// Bayeux 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.
//
// Bayeux 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 Bayeux.  If not, see <http://www.gnu.org/licenses/>.

#ifndef DATATOOLS_CONFIGURATION_VARIANT_SERVICE_H
#define DATATOOLS_CONFIGURATION_VARIANT_SERVICE_H

// Standard Library:
#include <string>
#include <vector>
#include <map>
#include <stdexcept>

// Third party:
// - Boost
#include <boost/cstdint.hpp>
#include <boost/program_options.hpp>
// - Bayeux:
#include <bayeux/bayeux.h>
// - Bayeux/datatools:
#include <datatools/configuration/variant_repository.h>
#include <datatools/configuration/io.h>

namespace datatools {

  namespace configuration {

    class variant_service
    {
    public:

      class variant_exception : public std::runtime_error {
      public:
        variant_exception(const std::string& msg) : std::runtime_error(msg) {}
      };

      enum config_flags {
        NO_LABEL                  = datatools::bit_mask::bit00,
        NO_LOGGING                = datatools::bit_mask::bit01,
        NO_CONFIG_FILENAME        = datatools::bit_mask::bit02,
        NO_REGISTRY_RULES         = datatools::bit_mask::bit03,
        NO_REGISTRY_DEPENDENCIES  = datatools::bit_mask::bit04,
        NO_PROFILE_LOAD           = datatools::bit_mask::bit05,
        PROFILE_LOAD_DONT_IGNORE_UNKNOWN = datatools::bit_mask::bit06,
        NO_SETTINGS               = datatools::bit_mask::bit07,
        NO_PROFILE_STORE          = datatools::bit_mask::bit08,
        NO_GUI                    = datatools::bit_mask::bit09,
        NO_TUI                    = datatools::bit_mask::bit10,
        NO_REPORTING              = datatools::bit_mask::bit11
      };

      struct config
      {
        config();

        bool is_active() const;

        void print(std::ostream & out_,
                   const std::string & title_ = "",
                   const std::string & indent_ = "") const;

        // Configuration parameters:
        std::string                     label;           
        std::string                     logging;         
        std::string                     config_filename; 
        std::vector<std::string>        registry_rules;  
        std::vector<std::string>        registry_dependencies; 
        std::string                     profile_load;    
        bool                            profile_load_dont_ignore_unknown = false; 
        std::vector<std::string>        settings;        
        std::string                     profile_store;   
#if DATATOOLS_WITH_QT_GUI == 1
        bool                            gui = false;        
#endif // DATATOOLS_WITH_QT_GUI == 1
        bool                            tui = false;        
        std::string                     reporting_filename; 
      };

      static void init_options(boost::program_options::options_description & opts_,
                               config & cfg_,
                               uint32_t flags_ = 0);

      struct registry_record
      {
        registry_record();

        int init_registry(int & max_rank_, const std::string & registry_rule_);

        int add_dependency(const std::string & registry_dependency_rule_);

        bool is_valid() const;

        const std::string & get_name() const;

        const std::string & get_display_name() const;

        const std::string & get_description() const;

        int get_rank() const;

        const std::string & get_config_file() const;

        const std::vector<std::string> & get_dependencies() const;

        // Attributes:
        std::string _name_;         
        std::string _display_name_; 
        std::string _description_;  
        int         _rank_;         
        std::string _config_file_;  
        std::vector<std::string> _dependencies_; 

      };

      typedef std::map<std::string, registry_record> registry_record_dict_type;

      // Default Constructor
      variant_service(uint32_t flags_ = 0);

      // Destructor
      ~variant_service();

      void set_label(const std::string &);

      const std::string & get_label() const;

      void set_logging(datatools::logger::priority);

      void set_repository_config(const std::string & config_);

      void add_registry_rule(const std::string & registry_rule_);

      void add_registry_dependency(const std::string & registry_dependency_rule_);

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

      void set_input_profile(const std::string & ip_);

      void set_dont_ignore_unknown_at_load(bool);

      void set_settings(const std::vector<std::string> & setting_);

      void set_output_profile(const std::string & op_);

      bool is_reporting() const;

      bool has_reporting_file() const;

      void set_reporting_file(const std::string & urf_);

      void configure(const config & cfg_, bool lock_ = true);

      int32_t get_max_rank() const;

      int32_t get_next_rank() const;

      // //! Return the first free rank for registries
      // int32_t get_free_rank() const;

#if DATATOOLS_WITH_QT_GUI == 1
      void set_gui(bool);
#endif // DATATOOLS_WITH_QT_GUI == 1

      void set_tui(bool);

      bool is_started() const;

      void start();

      void stop();

      void apply_setting(const std::string & setting_);

      variant_repository & grab_repository();

      const variant_repository & get_repository() const;

    private:

      // Private methods wrapped in start/stop actions:

      //----------------------------------------------------------------------
      void _do_build_();

      //----------------------------------------------------------------------
      void _do_variant_config_();

      //----------------------------------------------------------------------
      registry_record & _add_registry_record(const registry_record & registry_record_);

      //----------------------------------------------------------------------
      void _do_variant_additional_registries_setup_();

      //----------------------------------------------------------------------
      void _do_variant_load_profile_();

      //----------------------------------------------------------------------
      void _do_variant_store_profile_();

      //----------------------------------------------------------------------
      void _do_variant_apply_settings_();

#if DATATOOLS_WITH_QT_GUI == 1
      //----------------------------------------------------------------------
      void _do_variant_launch_gui_();
#endif // DATATOOLS_WITH_QT_GUI == 1

      //----------------------------------------------------------------------
      void _do_variant_launch_tui_();

      //----------------------------------------------------------------------
      void _do_variant_system_export_();

      //----------------------------------------------------------------------
      void _do_variant_system_discard_();

      //----------------------------------------------------------------------
      void _do_variant_reporting_init_();

      //----------------------------------------------------------------------
      void _do_variant_reporting_fini_();

    private:

      // Configuration:
      datatools::logger::priority _logging_;           
      std::string                 _label_;             
      std::string                 _repository_config_; 
      std::vector<std::string>    _registry_rules_;    
      std::vector<std::string>    _registry_deps_;     
      std::string                 _input_profile_;     
      std::vector<std::string>    _settings_;          
      std::string                 _output_profile_;    
      bool                        _dont_ignore_unknown_at_load_ = false; 
 #if DATATOOLS_WITH_QT_GUI == 1
      bool                        _gui_ = false;       
#endif // DATATOOLS_WITH_QT_GUI == 1
      bool                        _tui_ = false;       
      std::string                 _reporting_file_;    

      // Embedded working data:
      bool                      _started_;    
      registry_record_dict_type _registries_; 
      variant_repository        _repository_; 
      variant_reporting         _reporting_;  

    };

  } // namespace configuration

} // namespace datatools

#endif // DATATOOLS_CONFIGURATION_VARIANT_SERVICE_H

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