Parity.hh

//
// This file is part of MARLEY (Model of Argon Reaction Low Energy Yields)
//
// MARLEY is free software: you can redistribute it and/or modify it under the
// terms of version 3 of the GNU General Public License as published by the
// Free Software Foundation.
//
// For the full text of the license please see COPYING or
// visit http://opensource.org/licenses/GPL-3.0
//
// Please respect the MCnet academic usage guidelines. See GUIDELINES
// or visit https://www.montecarlonet.org/GUIDELINES for details.
 
#pragma once
 
// Standard library includes
#include <ostream>
 
namespace marley {

  class Parity {
 
    public:

      constexpr Parity() : is_positive_(true) {}

      constexpr explicit Parity(bool is_positive)
        : is_positive_(is_positive) {}

      explicit Parity(int i);

      constexpr explicit operator bool() const { return is_positive_; }

      constexpr marley::Parity operator-() const {
        return marley::Parity(!is_positive_);
      }

      inline Parity& operator!() {
        is_positive_ = !is_positive_;
        return *this;
      }

      marley::Parity& operator=(const int& i);
 
      inline bool operator==(const marley::Parity& p) const
      {
        return is_positive_ == p.is_positive_;
      }
 
      inline bool operator!=(const marley::Parity& p) const
      {
        return is_positive_ != p.is_positive_;
      }
 
      inline marley::Parity operator*(const marley::Parity& p) const
      {
        return marley::Parity(is_positive_ == p.is_positive_);
      }
 
      inline int operator*(const int& i) const
      {
        if (is_positive_) return i;
        else return -i;
      }
 
      // Allows explicit casts of marley::Parity to int
      inline explicit operator int() const {
        if (is_positive_) return 1;
        else return -1;
      }

      inline char to_char() const {
        if (is_positive_) return '+';
        else return '-';
      }

      void from_char(const char c);
 
    protected:

      bool is_positive_;
  };
 
}
 
inline int operator*(const int& i, const marley::Parity& p)
{
  if (static_cast<bool>(p)) return i;
  else return -i;
}
 
inline std::ostream& operator<<(std::ostream& out, const marley::Parity& p)
{
  out << p.to_char();
  return out;
}
 
std::istream& operator>> (std::istream& in, marley::Parity& p);