PointCharge.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_RECOBASE_CHARGE_H
#define LARDATAOBJ_RECOBASE_CHARGE_H

// C/C++ standard libraries
#include <limits>
#include <string>
#include <utility> // std::forward()
#include <iosfwd> // std::ostream


namespace recob {
  
  class PointCharge {
    
      public:
    
    using Charge_t = float; 
    
    static constexpr Charge_t InvalidCharge
      = std::numeric_limits<Charge_t>::lowest();
    
    
    //--- BEGIN Constructors ---------------------------------------------------
      
    constexpr PointCharge(): fCharge(InvalidCharge) {}
    
    constexpr PointCharge(Charge_t charge): fCharge(charge) {}
    
    //--- END Constructors -----------------------------------------------------
    
    
    //--- BEGIN Accessors ------------------------------------------------------
    
    constexpr Charge_t charge() const { return fCharge; }
    
    //--- END Accessors --------------------------------------------------------
    
    
    //--- BEGIN Status ---------------------------------------------------------
    
    constexpr bool hasCharge() const { return charge() != InvalidCharge; }
    
    //--- END Status -----------------------------------------------------------
    
    
    //--- BEGIN Printing operations --------------------------------------------
    
    static constexpr unsigned int DefaultVerbosity = 1U;
    
    static constexpr unsigned int MaxVerbosity = 1U;
    
    template <typename Stream>
    void dump(
      Stream&& out, unsigned int verbosity,
      std::string indent, std::string firstIndent
      ) const;
    
    // variants for the implementation of default values
    template <typename Stream>
    void dump
      (Stream&& out, unsigned int verbosity, std::string indent = "") const
      { dump(std::forward<Stream>(out), verbosity, indent, indent); }
    template <typename Stream>
    void dump(Stream&& out, std::string indent, std::string firstIndent) const
      { dump(std::forward<Stream>(out), DefaultVerbosity, indent, firstIndent); }
    template <typename Stream>
    void dump(Stream&& out, std::string indent = "") const
      { dump(std::forward<Stream>(out), indent, indent); }
    
    //--- END Printing operations ----------------------------------------------
    
      private:
    float fCharge; 
    
  }; // class PointCharge
  
  
  inline std::ostream& operator<<
    (std::ostream& out, recob::PointCharge const& charge)
    { charge.dump(out); return out; }
  
  
} // namespace recob



//------------------------------------------------------------------------------
//---  template implementation
//--- 
template <typename Stream>
void recob::PointCharge::dump(
  Stream&& out, unsigned int verbosity,
  std::string indent, std::string firstIndent
  ) const
{
  if (verbosity <= 0U) return;
  
  //----------------------------------------------------------------------------
  out << firstIndent
    << "charge: ";
  if (hasCharge()) out << charge();
  else             out << "none";
  
//  if (verbosity <= 1U) return;
  //----------------------------------------------------------------------------
  // if the following check fails,
  // consistency between `dump()` and `MaxVerbosity` needs to be restored
  static_assert(MaxVerbosity == 1U, "Please update the code!");
  
} // recob::PointCharge::dump()


//------------------------------------------------------------------------------

#endif // LARDATAOBJ_RECOBASE_CHARGE_H