PointCharge.h

Go to the documentation of this file.

#ifndef LARDATAOBJ_RECOBASE_CHARGE_H
#define LARDATAOBJ_RECOBASE_CHARGE_H

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

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