manager.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2013-02-24
 * Last modified :
 *
 * Copyright (C) 2011-2013 Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Copyright (C) 2012 Ben Morgan <Ben.Morgan@warwick.ac.uk>
 *
 * 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 particle generator manager.
 *
 * History:
 *
 */
#ifndef GENBB_HELP_MANAGER_H
#define GENBB_HELP_MANAGER_H 1

// Standard Library
#include <string>
#include <sstream>
#include <typeinfo>
#include <stdexcept>

// Third Party
// - Boost
#include <boost/cstdint.hpp>

// Datatools
#include <datatools/i_tree_dump.h>
#include <datatools/bit_mask.h>
#include <datatools/logger.h>

// Mygsl
#include <mygsl/rng.h> // Pseudo random number generator

// genbb_help
#include <genbb_help/detail/pg_tools.h>
#include <genbb_help/i_genbb.h>

namespace datatools {
  class properties;
  class multi_properties;
  class service_manager;
}

namespace genbb {

  class manager
    : public ::datatools::i_tree_dumpable
  {
  public:
    enum flag_type {
      BLANK              = 0,
      NO_PRELOAD         = datatools::bit_mask::bit00,
      FORCE_INITIALIZATION_AT_LOAD = datatools::bit_mask::bit01
    };

  public:

    bool has_service_manager() const;

    void set_service_manager(datatools::service_manager & service_mgr_);

    void reset_service();

    manager(datatools::logger::priority p_ = datatools::logger::PRIO_WARNING, int flags_ = 0);

    ~manager();

    bool is_debug() const;

    void set_debug(bool debug_ = true);

    bool has_external_prng() const;

    void set_external_prng(mygsl::rng &);

    void reset_external_prng();

    mygsl::rng & grab_external_prng();

    const mygsl::rng & get_external_prng() const;

    mygsl::rng & grab_embedded_prng();

    const mygsl::rng & get_embedded_prng() const;

    void set_embedded_prng_seed(int seed_);

    mygsl::rng & grab_prng();

    const mygsl::rng & get_prng() const;

    bool has_default_generator() const;

    void set_default_generator(const std::string &);

    const std::string & get_default_generator() const;

    bool is_initialized() const;

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

    void reset();

    bool has_pg_type(const std::string & id_) const;

    template <class PgClass>
    void register_pg_type(const std::string & id_);

    void unregister_pg_type(const std::string & id_);

    bool has(const std::string & name_) const;

    bool is_initialized(const std::string & name_) const;

    bool can_drop(const std::string & name_) const;

    void drop(const std::string & name_);

    void reset(const std::string & name_);

    const std::string & get_id(const std::string & name_) const;

    const i_genbb & get(const std::string & name_) const;

    i_genbb & grab(const std::string & name_);

    void load(const std::string & name_,
              const std::string & id_,
              const datatools::properties & config_);

    void load(const datatools::multi_properties & config_);

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

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

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

    const datatools::factory_register<i_genbb> & get_factory_register() const;

    datatools::factory_register<i_genbb> & grab_factory_register();

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

    void set_logging_priority(datatools::logger::priority p_);

  protected:

    // Note: move to private ASAP

    void _load_pg(const std::string & name_,
                  const std::string & id_,
                  const datatools::properties & config_);

    void _preload_global_dict();

    void _create_pg(detail::pg_entry_type & entry_);

    void _initialize_pg(detail::pg_entry_type & entry_);

    void _reset_pg(detail::pg_entry_type & entry_);

  private:

    void _set_preload_(bool preload_);

  private:

    datatools::service_manager * _service_mgr_ = nullptr; 

    bool         _initialized_;                     
    datatools::logger::priority _logging_priority_; 
    bool         _preload_;                         
    bool         _force_initialization_at_load_;    
    std::string   _default_generator_; 

    mygsl::rng * _external_prng_;      
    int          _embedded_prng_seed_; 
    mygsl::rng   _embedded_prng_;      

    datatools::factory_register<i_genbb> _factory_register_;    
    detail::pg_dict_type                 _particle_generators_; 

  };


  template <class PgClass>
  void manager::register_pg_type(const std::string & id_)
  {
    _factory_register_.registration(id_, boost::factory<PgClass*>());
  }

}  // end of namespace genbb

/***************
 * OCD support *
 ***************/
#include <datatools/ocd_macros.h>
DOCD_CLASS_DECLARATION(genbb::manager)

#endif // GENBB_HELP_MANAGER_H

// Local Variables: --
// mode: c++ --
// End: --