kernel.h

Go to the documentation of this file.

/* Author(s):     Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2013-09-26
 * Last modified: 2016-06-25
 *
 * License:
 *
 * Copyright (C) 2013-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:
 *
 *  The datatools kernel singleton with embedded resources and components.
 *
 */

#ifndef DATATOOLS_KERNEL_H
#define DATATOOLS_KERNEL_H

// Standard Library:
#include <iostream>
#include <memory>

// Third Party:
#include <boost/noncopyable.hpp>
#include <boost/cstdint.hpp>

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-local-typedef"
#endif
#include <boost/program_options.hpp>
#ifdef __clang__
#pragma clang diagnostic pop
#endif

// This project:
#include <datatools/logger.h>
#include <datatools/i_tree_dump.h>
#include <datatools/datatools_config.h>
#include <datatools/bit_mask.h>
#include <datatools/datatools_init.h>

namespace datatools {

  // Forward declaration:
  class service_manager;
  class urn_query_service;
  class library_query_service;
  class library_info;

  namespace configuration {

    // Forward declaration:
    class variant_repository;
    class variant_service;

  }

  class kernel
    : private boost::noncopyable
    , public ::datatools::i_tree_dumpable
  {

  public:

    struct param_type {

    public:

      param_type();

      void reset();

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

    public:

      bool                     help = false;            
      std::string              logging_label = "fatal";   
      std::string              locale_category; 
      std::string              library_query_logging_label = "fatal";  
      bool                     inhibit_library_query = false; 
      bool                     inhibit_urn_query = false;    
      bool                     inhibit_variant_repository = false;    
      std::vector<std::string> unrecognized_args; 
      std::vector<std::string> resource_paths;    
      std::string              variant_config;    
      std::vector<std::string> variant_registry_configs; 
      std::string              variant_load;   
      std::string              variant_store;  
      std::vector<std::string> variant_sets;   

      bool                     splash = false;         
#if DATATOOLS_WITH_QT_GUI == 1
      bool                     inhibit_qt_gui = false; 
      bool                     variant_qt_gui = false; 
      std::string              variant_qt_gui_style = "plastique"; 
#endif // DATATOOLS_WITH_QT_GUI == 1

    };

    static const uint32_t init_mask = datatools::bit_mask::nbits15;

    enum init_flags {
      // Import value from datatools_init_flags:
      init_no_help             = datatools::init_no_help,
      init_no_splash           = datatools::init_no_splash,
      init_no_locale_category  = datatools::init_no_locale_category,
      init_no_logging          = datatools::init_no_logging,
      init_no_inhibit_libquery = datatools::init_no_inhibit_libquery,
      init_no_libquery_logging = datatools::init_no_libquery_logging,
      init_no_inhibit_libinfo  = datatools::init_no_inhibit_libinfo, 
      init_no_libinfo_logging  = datatools::init_no_libinfo_logging, 
      init_no_resource_path    = datatools::init_no_resource_path,
      init_no_inhibit_variant  = datatools::init_no_inhibit_variant,
      init_no_variant          = datatools::init_no_variant,
      init_no_inhibit_qt_gui   = datatools::init_no_inhibit_qt_gui,
      init_no_inhibit_urnquery = datatools::init_no_inhibit_urnquery,
      init_reserved_11         = datatools::init_reserved_11,
      init_reserved_12         = datatools::init_reserved_12,
      init_reserved_13         = datatools::init_reserved_13,
      init_reserved_14         = datatools::init_reserved_14,
    };

    kernel();

    kernel(int argc_, char * argv_[], uint32_t flags = 0);

    virtual ~kernel();

    void initialize(int argc_, char * argv_[], uint32_t flags_ = 0);

    void shutdown();

    bool is_initialized() const;

    datatools::logger::priority get_logging() const;

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

    bool has_services() const;

    bool has_urn_query() const;

    urn_query_service & grab_urn_query();

    const urn_query_service & get_urn_query() const;

    bool has_library_query() const;

    library_query_service & grab_library_query();

    const library_query_service & get_library_query() const;

    bool has_library_info_register() const;

    library_info & grab_library_info_register();

    const library_info & get_library_info_register() const;

    bool has_variant_repository() const;

    const configuration::variant_repository & get_variant_repository() const;

    configuration::variant_repository & grab_variant_repository();

    bool has_variant_service() const;

    const configuration::variant_service & get_variant_service() const;

    configuration::variant_service & grab_variant_service();

    void set_variant_service(configuration::variant_service & var_serv_);

    void reset_variant_service();

    bool has_effective_variant_repository() const;

    const configuration::variant_repository & get_effective_variant_repository() const;

    configuration::variant_repository & grab_effective_variant_repository();

    bool has_locale_category() const;

    void set_locale_category(const std::string & lc_);

    const std::string & get_locale_category() const;

    const std::string & get_application_name() const;

    bool has_application_name() const;

    static bool is_instantiated();

    static kernel & instance();

    static kernel & instantiate();

    static const kernel & const_instance();

    static void build_opt_desc(boost::program_options::options_description &, param_type &, uint32_t flags_ = 0);

    static void print_splash(std::ostream & = std::clog);

    static void print_opt_desc(const boost::program_options::options_description &,
                               std::ostream & = std::clog,
                               const std::string & indent_ = "");

#if DATATOOLS_WITH_QT_GUI == 1
    bool is_qt_gui_activated() const;
#endif // DATATOOLS_WITH_QT_GUI == 1

    unsigned int get_nargs() const;

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

    int get_argc() const;

    char ** get_argv() const;

    char * get_argv(int i_) const;

    bool is_library_info_register_activated() const;

    bool is_library_query_service_activated() const;

    bool is_urn_query_service_activated() const;

    bool is_variant_repository_activated() const;

    bool is_variant_service_allowed() const;

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

    void register_resource_paths();

    void register_configuration_variant_registries();

    void import_configuration_registry(configuration::variant_repository & rep_,
                                       const std::string & registry_name_ = "");

    bool has_configuration_registries() const;

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

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

    void import_configuration_repository(configuration::variant_repository & rep_);

    void clear_configuration_repository();

    void clear_imported_configuration_repository();

  private:

    void _initialize_();

    void _shutdown_();

    void _set_defaults_();

    void _construct_();

    void _initialize_services_();

    void _shutdown_services_();

    void _initialize_library_query_service_();

    void _shutdown_library_query_service_();

    void _initialize_urn_query_service_();

    void _shutdown_urn_query_service_();

    void _initialize_configuration_variant_repository_();

  private:

    // Management:
    bool             _initialized_ = false; 
    param_type       _params_;           
    logger::priority _logging_;          

    // Configuration parameters:
    std::string      _locale_category_;  
    std::string      _application_name_; 
    unsigned int     _nargs_ = 0;
    std::vector<std::string> _args_; 
    int              _argc_ = 0;             
    char **          _argv_ = nullptr;       
    std::vector<std::string> _unrecognized_args_; 
    bool             _activate_library_query_service_ = true; 
    bool             _activate_urn_query_service_ = true;     
    bool             _activate_variant_repository_ = true;    
    bool             _allowed_variant_service_ = true;        
#if DATATOOLS_WITH_QT_GUI == 1
    bool            _activate_qt_gui_ = true; 
#endif // DATATOOLS_WITH_QT_GUI == 1

    // Working internals:
    std::unique_ptr<datatools::service_manager> _services_; 
    std::unique_ptr<configuration::variant_repository> _variant_repository_; 
    configuration::variant_service * _variant_service_ = nullptr; 
#if DATATOOLS_WITH_QT_GUI == 1
    //    QApplication  * _qapp_; //!< Handle to the Qt application
#endif // DATATOOLS_WITH_QT_GUI == 1

    // Singleton:
    static kernel * _instance_; 

  };

} // end of namespace datatools

#endif // DATATOOLS_KERNEL_H

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