base_module.h

Go to the documentation of this file.

/* Author(s)     :     Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2011-06-07
 * Last modified : 2013-12-13
 *
 * Copyright (C) 2011-2013 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:
 *
 *   Base data processing module.
 *
 */

#ifndef DPP_BASE_MODULE_H
#define DPP_BASE_MODULE_H 1

// Standard library:
#include <iostream>
#include <string>

// Third party:
// - Bayeux/datatools:
#include <datatools/bit_mask.h>
#include <datatools/i_tree_dump.h>
#include <datatools/factory_macros.h>
#include <datatools/logger.h>
#include <datatools/things.h>

// This project:
#include <dpp/dpp_config.h>
#include <dpp/module_tools.h>

namespace datatools {
  // Forward class declarations :
  class properties;
  class multi_properties;
  class service_manager;
}

namespace dpp {

  class base_module
    : public datatools::i_tree_dumpable
  {
  public:

    enum process_status {
      PROCESS_OK       = 0,                          
      PROCESS_SUCCESS  = PROCESS_OK,                 
      PROCESS_CONTINUE = PROCESS_OK,                 
      PROCESS_ERROR    = datatools::bit_mask::bit00, 
      PROCESS_FAILURE  = PROCESS_ERROR,              
      PROCESS_STOP     = datatools::bit_mask::bit01, 
      PROCESS_ERROR_STOP = PROCESS_ERROR | PROCESS_STOP, 
      PROCESS_FATAL    = datatools::bit_mask::bit02, 
      PROCESS_INVALID  = datatools::bit_mask::bit31  
    };

    base_module(datatools::logger::priority p_ = datatools::logger::PRIO_FATAL);

    virtual ~base_module();

    bool has_name() const;

    void set_name(const std::string &);

    const std::string & get_name() const;

    bool has_description() const;

    const std::string & get_description() const;

    void set_description(const std::string & description_);

    bool has_last_error_message() const;

    void set_last_error_message(const std::string &);

    void append_last_error_message(const std::string & errmsg_);

    void reset_last_error_message();

    const std::string & get_last_error_message() const;

    bool is_initialized() const;

    virtual void initialize_simple();

    virtual void initialize_simple_with_service(datatools::service_manager & service_manager_);

    virtual void initialize_standalone(const datatools::properties & config_);

    virtual void initialize_with_service(const datatools::properties & config_,
                                         datatools::service_manager & service_manager_);

    virtual void initialize_without_service(const datatools::properties & config,
                                            module_handle_dict_type & module_dictionnary_);

    virtual void initialize(const datatools::properties & config_,
                            datatools::service_manager & service_manager_,
                            module_handle_dict_type & module_dictionary_) = 0;

    virtual process_status process(datatools::things & data_model_) = 0;

    virtual void reset() = 0;

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

    void print(std::ostream & out_ = std::clog) const;

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

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

    static void common_ocd(datatools::object_configuration_description & ocd_);

  protected:

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

    void _set_initialized(bool initialized_);

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

  protected:

    std::string _name;           
    std::string _description;    
    datatools::logger::priority _logging; 

    bool        _initialized;        
    std::string _last_error_message; 

    // Factory stuff :
    DATATOOLS_FACTORY_SYSTEM_REGISTER_INTERFACE(base_module)

  };

}  // end of namespace dpp

/* Macros for interface/implementation of static creator methods in module classes */

#define DPP_MODULE_REGISTRATION_INTERFACE(T)                            \
  private:                                                              \
  DATATOOLS_FACTORY_SYSTEM_AUTO_REGISTRATION_INTERFACE(::dpp::base_module,T) \
  

#define DPP_MODULE_REGISTRATION_IMPLEMENT(T,ModuleID)                   \
  DATATOOLS_FACTORY_SYSTEM_AUTO_REGISTRATION_IMPLEMENTATION(::dpp::base_module,T,ModuleID) \
  

#endif // DPP_BASE_MODULE_H

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