success-bin.hh

Go to the documentation of this file.

// Copyright (c) 2014, LAAS-CNRS
// Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
//
// This file is part of hpp-statistics.
// hpp-statistics is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation, either version
// 3 of the License, or (at your option) any later version.
//
// hpp-statistics 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 Lesser Public License for more details.  You should have
// received a copy of the GNU Lesser General Public License along with
// hpp-statistics. If not, see <http://www.gnu.org/licenses/>.
 
#ifndef HPP_STATISTICS_SUCCESSBIN_HH
#define HPP_STATISTICS_SUCCESSBIN_HH
 
#include <hpp/util/debug.hh>
#include <iostream>
#include <set>
 
#include "hpp/statistics/bin.hh"
#include "hpp/statistics/config.hh"
#include "hpp/statistics/fwd.hh"
 
#define HPP_DEFINE_REASON_FAILURE(ID, STRING)              \
  const ::hpp::statistics::SuccessBin::Reason ID =         \
      ::hpp::statistics::SuccessBin::createReason(STRING); \
  struct e_n_d__w_i_t_h__s_e_m_i_c_o_l_o_n
 
namespace hpp {
namespace statistics {
class HPP_STATISTICS_DLLAPI SuccessBin : public Bin {
 public:
  struct Reason {
    std::size_t id;
    std::string what;
    Reason(std::size_t a_id, std::string a_what) : id(a_id), what(a_what) {}
  };
 
  const static Reason REASON_UNKNOWN;
 
  SuccessBin(const bool success, const Reason& r = REASON_UNKNOWN)
      : Bin(), success_(success), reason_(r) {
    if (success_) reason_ = REASON_SUCCESS;
  }
 
  inline bool isSuccess() const { return success_; }
 
  inline const Reason& reason() const { return reason_; }
 
  inline const std::string& reasonString() const;
 
  inline bool operator==(const SuccessBin& other) const {
    return reason_.id == other.reason().id;
  }
 
  inline bool operator<(const SuccessBin& other) const {
    return reason_.id < other.reason().id;
  }
 
  static Reason createReason(const std::string& what) {
    return Reason(reasonID_last++, what);
  }
 
 private:
  bool success_;
  size_t freq_;
  Reason reason_;
 
  const static Reason REASON_SUCCESS;
  static std::size_t reasonID_last;
 
  inline std::ostream& printValue(std::ostream& os) const {
    os << "Event ";
    if (success_)
      os << "'Success'";
    else
      os << "'Failure': " << reason_.what;
    return os;
  }
};
 
class HPP_STATISTICS_DLLAPI SuccessStatistics : public Statistics<SuccessBin> {
 public:
  typedef Statistics<SuccessBin> Parent;
 
  SuccessStatistics(const std::string name = "",
                    const std::size_t& logRatio = 2)
      : name_(name), logRatio_(logRatio) {}
 
  SuccessStatistics(const SuccessStatistics& other)
      : name_(other.name_), logRatio_(other.logRatio_) {}
 
  void addSuccess() { insert(SuccessBin(true)); }
 
  void addFailure(const SuccessBin::Reason& r = SuccessBin::REASON_UNKNOWN) {
    insert(SuccessBin(false, r));
#ifdef HPP_DEBUG
    isLowRatio(true);
#endif
  }
 
  inline bool isLowRatio(const bool autoPrint = false) const {
    bool lowRatio = (logRatio_ * nbSuccess() < numberOfObservations());
    if (autoPrint && lowRatio) hppDout(info, name_ << ":\n" << *this);
    return lowRatio;
  }
 
  std::size_t nbSuccess() const { return freq(SuccessBin(true)); }
 
  std::size_t nbFailure() const { return numberOfObservations() - nbSuccess(); }
 
  std::size_t nbFailure(const SuccessBin::Reason& r) const {
    return freq(SuccessBin(false, r));
  }
 
  std::string name_;
 
  std::size_t logRatio_;
};
}  // namespace statistics
}  // namespace hpp
 
#endif  // HPP_STATISTICS_SUCCESSBIN_HH