i_cut.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2011-06-07
 * Last modified : 2015-11-09
 *
 * Copyright (C) 2011-2015 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 cut.
 *
 * History:
 *
 */

#ifndef CUTS_I_CUT_H
#define CUTS_I_CUT_H 1

// Standard library:
#include <ostream>
#include <string>
#include <typeinfo>
#include <set>

// Third party:
// - Boost:
#include <boost/cstdlib.hpp>
#include <boost/shared_ptr.hpp>
// - Bayeux/datatools:
#include <datatools/i_tree_dump.h>
#include <datatools/factory_macros.h>
#include <datatools/bit_mask.h>
#include <datatools/logger.h>

// This project:
#include <cuts/cut_tools.h>

namespace datatools {
  class properties;
  class service_manager;
}

namespace cuts {

  class i_cut : public datatools::i_tree_dumpable
  {
  public:

    struct i_referenced_data {
      virtual operator bool() const = 0;
      virtual const std::type_info * get_typeinfo() const = 0;
      virtual bool match(const std::type_info * tit_) const = 0;
      virtual ~i_referenced_data() {}
    };

    template<class T>
    struct referenced_data : public i_referenced_data {
    public:
      const T & get() const {
        DT_THROW_IF(_address == 0,
                    std::logic_error,
                    "No referenced data !"
                    );
        return *_address;
      }
      virtual const std::type_info * get_typeinfo() const {
        return _ti;
      }
      virtual bool match(const std::type_info * tit_) const {
        return tit_ == _ti;
      }
      void set(const T & obj) {
        _address = &obj;
        _ti = &typeid(T);
      }
      virtual operator bool() const {
        return _address != 0 && _ti != 0;
      }
      void reset() {
        _address = 0;
        _ti = 0;
      }
      referenced_data() {
        _address = 0;
        _ti = 0;
      }
      referenced_data(const T & obj) {
        set(obj);
      }
      virtual ~referenced_data() {
        _address = 0;
        _ti = 0;
      }
    protected:
      const T              * _address; 
      const std::type_info * _ti;      
    };

    bool is_debug() const;

    bool has_name() const;

    void set_name(const std::string & a_name);

    const std::string & get_name() const;

    bool has_description() const;

    const std::string & get_description() const;

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

    bool has_version() const;

    const std::string & get_version() const;

    void set_version(const std::string & a_version);

    bool is_initialized() const;

    bool has_user_data() const;

    template<class T>
    void set_user_data(const T & obj_)
    {
      DT_LOG_TRACE(_logging,
                   "Cut '" << (has_name() ? get_name() : "?") << "' : "
                   << "adding user data of type '" << typeid(T).name() << "'...");
      // DT_THROW_IF(!is_user_data_type_supported<T>(),
      //             std::logic_error,
      //             "User data type '" << typeid(T).name() << "' is not supported by cut '" << get_name() << "'!");
      boost::shared_ptr<i_referenced_data> ud(new referenced_data<T>(obj_));
      _set_user_data(ud);
    }

    template<class T>
    bool is_user_data() const
    {
      DT_THROW_IF(! _user_data_,
                  std::logic_error,
                  "Cut '" << (has_name()?get_name():"?") << "' does not reference any user data of type '" << typeid(T).name() << "' !");
      const std::type_info & ti = typeid(T);
      return _user_data_.get()->match(&ti);
    }

    template<class T>
    const T & get_user_data() const
    {
      DT_THROW_IF(! is_user_data<T>(),
                  std::logic_error,
                  "Invalid request on user data for cut named '" << (has_name()?get_name():"?") << "' !");
      const referenced_data<T> * rd = dynamic_cast<const referenced_data<T> *>(_user_data_.get());
      DT_THROW_IF(rd == 0,
                  std::logic_error,
                  "Invalid cast for reference data in cut named '" << (has_name()?get_name():"?") << "' !");
      return rd->get();
    }

    template<class T>
    void register_supported_user_data_type()
    {
      const std::type_info & ti = typeid(T);
      DT_LOG_DEBUG(_logging, "Registering supported type '" << ti.name() << "' !!!");
      _supported_types_.insert(&ti);
      return;
    }

    template<class T>
    void unregister_supported_user_data_type()
    {
      const std::type_info & ti = typeid(T);
      DT_LOG_DEBUG(_logging, "Unregistering supported type '" << ti.name() << "' !!!");
      _supported_types_.erase(&ti);
      return;
    }

    template<class T>
    bool is_user_data_type_supported() const
    {
      if (_supported_types_.size() == 0) {
        DT_LOG_TRACE(_logging, "Supported type");
        return true;
      }
      DT_LOG_TRACE(_logging, "Checking supported type...");
      const std::type_info & ti = typeid(T);
      if (_supported_types_.count(&ti) == 1) {
        DT_LOG_TRACE(_logging, "Supported registered type.");
        return true;
      }
      return false;
    }

    bool is_user_data_type_supported(const std::type_info & tinfo_) const;

    void reset_user_data();

    virtual void initialize_simple();

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

    virtual void initialize_with_service_only(const datatools::properties & a_config,
                                              datatools::service_manager & a_service_manager);

    virtual void initialize_without_service(const datatools::properties & a_config,
                                            cut_handle_dict_type & a_cut_dictionary);

    virtual void initialize(const datatools::properties & a_config,
                            datatools::service_manager & a_service_manager,
                            cut_handle_dict_type & a_cut_dictionary) = 0;

    enum export_config_flags {
      EXPORT_CONFIG_CLEAR             = datatools::bit_mask::bit00,
      EXPORT_CONFIG_NAME              = datatools::bit_mask::bit01,
      EXPORT_CONFIG_DESCRIPTION       = datatools::bit_mask::bit02,
      EXPORT_CONFIG_VERSION           = datatools::bit_mask::bit03,
      EXPORT_CONFIG_LOGGING_PRIORITY  = datatools::bit_mask::bit04,
      EXPORT_CONFIG_DEFAULT           = (EXPORT_CONFIG_CLEAR |
                                         EXPORT_CONFIG_DESCRIPTION |
                                         EXPORT_CONFIG_VERSION),
      EXPORT_CONFIG_LAST              = EXPORT_CONFIG_LOGGING_PRIORITY
    };

    virtual void export_to_config(datatools::properties & config_,
                                  uint32_t flags_ = EXPORT_CONFIG_DEFAULT,
                                  const std::string & prefix_ = "") const;

    virtual int process();

    int operator()();

    virtual void reset() = 0;

    explicit i_cut(datatools::logger::priority p = datatools::logger::PRIO_FATAL);

    virtual ~i_cut();

    virtual void tree_dump(std::ostream & a_out         = std::clog,
                           const std::string & a_title  = "",
                           const std::string & a_indent = "",
                           bool a_inherit          = false) const;

    void print(std::ostream & a_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_);

    size_t get_number_of_accepted_entries() const;

    size_t get_number_of_rejected_entries() const;

    size_t get_number_of_processed_entries() const;

    void reset_counters();

    bool is_activated_counters() const;

    void set_activated_counters(bool);

  protected:

    virtual int _accept() = 0;

    void _set_user_data(const boost::shared_ptr<i_referenced_data> & hd_);

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

    void _import_user_data_from(const i_cut &);

    void _export_user_data_to(i_cut &) const;

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

    void _set_initialized(bool a_initialized);

    virtual void _prepare_cut();

    virtual int _finish_cut(int a_selection_status);

    virtual void _increment_counters(int a_selection_status);

    virtual void _at_set_user_data();

    virtual void _at_reset_user_data();

    void _reset();

    void _set_defaults();

  protected:

    // Configuration parameters:
    datatools::logger::priority _logging; 
    std::string  _name;          
    std::string  _description;   
    std::string  _version;       
    std::set<const std::type_info *> _supported_types_; 

  private:

    // Status:
    bool _initialized_; 

    // Working data:
    bool _activated_counters_; 
    boost::shared_ptr<i_referenced_data> _user_data_; 
    size_t _number_of_accepted_entries_; 
    size_t _number_of_rejected_entries_; 

  public:

    virtual std::string get_type_id() const = 0;

    // Factory stuff :
    DATATOOLS_FACTORY_SYSTEM_REGISTER_INTERFACE(i_cut)

  };

}  // end of namespace cuts

#define CUT_REGISTRATION_INTERFACE(T)           \
  public:                                       \
  virtual std::string get_type_id() const; \
  private:                                                                \
  DATATOOLS_FACTORY_SYSTEM_AUTO_REGISTRATION_INTERFACE(::cuts::i_cut, T) \
  

#define CUT_REGISTRATION_IMPLEMENT(T,CutID)               \
  std::string T::get_type_id() const { return CutID; } \
  DATATOOLS_FACTORY_SYSTEM_AUTO_REGISTRATION_IMPLEMENTATION(::cuts::i_cut, T, CutID) \
  

#endif // CUTS_I_CUT_H

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