base_hit.h

Go to the documentation of this file.

/* Author(s) :    Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2010-03-16
 * Last modified: 2018-08-16
 *
 * License: GPL3
 *
 * Description:
 *
 *   Base hit. 
 *
 */

#ifndef GEOMTOOLS_BASE_HIT_H
#define GEOMTOOLS_BASE_HIT_H 1

// Third party:
// - Boost:
#include <boost/serialization/access.hpp>
#include <boost/cstdint.hpp>
// - Bayeux/datatools :
#include <datatools/i_serializable.h>
#include <datatools/i_tree_dump.h>
#include <datatools/i_clear.h>
#include <datatools/i_predicate.h>
#include <datatools/bit_mask.h>
#include <datatools/properties.h>
#include <datatools/factory_macros.h>

// This project :
#include <geomtools/geomtools_config.h>
#include <geomtools/geom_id.h>
#include <datatools/properties.h>

namespace geomtools {

  class base_hit :
    public datatools::i_serializable,
    public datatools::i_tree_dumpable,
    public datatools::i_clear
  {
  public:

    enum store_mask_type {
      STORE_NOTHING     = 0,
      STORE_HIT_ID      = datatools::bit_mask::bit00, 
      STORE_GEOM_ID     = datatools::bit_mask::bit01, 
      STORE_AUXILIARIES = datatools::bit_mask::bit02, 
      STORE_RESERVED30  = datatools::bit_mask::bit30, 
      STORE_RESERVED31  = datatools::bit_mask::bit31  
    };

    static const int32_t INVALID_HIT_ID = -1;

    bool has_hit_id () const;

    int32_t get_hit_id () const;

    void set_hit_id (int32_t);

    void invalidate_hit_id ();

    bool has_geom_id () const;

    const geomtools::geom_id & get_geom_id () const;

    geomtools::geom_id & grab_geom_id ();

    void set_geom_id (const geomtools::geom_id &);

    void invalidate_geom_id ();

    bool has_auxiliaries () const;

    const datatools::properties & get_auxiliaries () const;

    datatools::properties & grab_auxiliaries ();

    void set_auxiliaries (const datatools::properties &);

    void invalidate_auxiliaries ();

    base_hit ();

    virtual ~base_hit ();


    virtual bool is_valid () const;

    virtual void invalidate ();

    void reset ();

    virtual void clear ();

    /*  measurement */

    class i_measurement
    {
    public:

      virtual void do_measurement (base_hit &) = 0;

      base_hit & operator () (base_hit &);

    };

    base_hit & measure (i_measurement &);

    /* interface i_tree_dumpable */

    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_tree(std::ostream & out_ = std::clog,
                    const boost::property_tree::ptree & options_ = datatools::i_tree_dumpable::empty_options()) const override;
      
    void dump() const;

    /* predicates */

    class has_flag_predicate : public datatools::i_predicate<base_hit>
    {
      std::string flag_; 

    public:

      explicit has_flag_predicate (const std::string & a_flag)
      {
        flag_ = a_flag;
        return;
      }

      bool operator () (const base_hit & a_hit) const
      {
        return (a_hit.get_auxiliaries ().has_flag (flag_));
      }

    };

    class has_key_predicate : public datatools::i_predicate<base_hit>
    {
      std::string key_; 

    public:

      explicit has_key_predicate (const std::string & a_key)
      {
        key_ = a_key;
        return;
      }

      bool operator () (const base_hit & a_hit) const
      {
        return (a_hit.get_auxiliaries ().has_key (key_));
      }

    };

    class has_string_property_predicate : public datatools::i_predicate<base_hit>
    {
      std::string key_; 
      std::vector<std::string> values_; 

    public:

      explicit has_string_property_predicate (const std::string & a_key,
                                              const std::string & a_value)
      {
        key_ = a_key;
        values_.push_back (a_value);
        return;
      }

      explicit has_string_property_predicate (const std::string & a_key,
                                              const std::vector<std::string> & a_values)
      {
        key_ = a_key;
        values_ = a_values;
        return;
      }

      bool operator () (const base_hit & a_hit) const
      {
        if (! a_hit.get_auxiliaries ().has_key (key_)) return false;
        if (! a_hit.get_auxiliaries ().is_string (key_)) return false;
        const std::string & str = a_hit.get_auxiliaries ().fetch_string (key_);
        return (std::find (values_.begin (),
                           values_.end (),
                           str) != values_.end ());
      }

    };

    class has_hit_id_predicate : public datatools::i_predicate<base_hit>
    {
    public:

      explicit has_hit_id_predicate (int a_hid)
      {
        hid_ = a_hid;
        return;
      }

      bool operator () (const base_hit & a_hit) const
      {
        return (a_hit.has_hit_id () && a_hit.get_hit_id () == hid_);
      }

    private:

      int hid_; 

    };


    class has_geom_id_predicate : public datatools::i_predicate<base_hit>
    {
    public:

      explicit has_geom_id_predicate (const geomtools::geom_id & a_gid)
      {
        gid_ = a_gid;
        return;
      }

      bool operator () (const base_hit & a_hit) const
      {
        return (a_hit.has_geom_id () && a_hit.get_geom_id () == gid_);
      }

    private:

      geomtools::geom_id gid_; 

    };


    class negates_predicate : public datatools::i_predicate<base_hit>
    {
    public:

      explicit negates_predicate (const datatools::i_predicate<base_hit> & a_pred)
      {
        pred_ = &a_pred;
        return;
      }

      bool operator () (const base_hit & a_hit) const
      {
        return (! (*pred_)(a_hit));
      }

    private:

      const datatools::i_predicate<base_hit> * pred_;

    };

  protected:

    void _store_set(uint32_t bit_mask_);

    void _store_unset(uint32_t bit_mask_);

    bool _store_check(uint32_t bit_mask_) const;

    uint32_t              _store;

  private:

    int32_t               _hit_id_;      
    geomtools::geom_id    _geom_id_;     
    datatools::properties _auxiliaries_; 

    DATATOOLS_SERIALIZATION_DECLARATION()

    
    DR_CLASS_RTTI()

    // Factory stuff :
    DATATOOLS_FACTORY_SYSTEM_REGISTER_INTERFACE(base_hit)

    DATATOOLS_FACTORY_SYSTEM_AUTO_REGISTRATION_INTERFACE(::geomtools::base_hit, base_hit)
    
  };

} // end of namespace geomtools

#include <boost/serialization/export.hpp>
BOOST_CLASS_EXPORT_KEY2(geomtools::base_hit, "geomtools::base_hit")

// Activate reflection layer for the geomtools::base_hit class :
DR_CLASS_INIT(::geomtools::base_hit)

// Class version:
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(geomtools::base_hit, 1)

#define GEOMTOOLS_HIT_REGISTRATION_INTERFACE(HitClassName)          \
  private:                                                              \
  DATATOOLS_FACTORY_SYSTEM_AUTO_REGISTRATION_INTERFACE(::geomtools::base_hit,HitClassName) \
  

#define GEOMTOOLS_HIT_REGISTRATION_IMPLEMENT(HitClassName,HitClassId) \
  DATATOOLS_FACTORY_SYSTEM_AUTO_REGISTRATION_IMPLEMENTATION(::geomtools::base_hit,HitClassName,HitClassId) \
  

#endif // GEOMTOOLS_BASE_HIT_H

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