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 <iostream>
# include <set>

# include <hpp/util/debug.hh>

# include "hpp/statistics/config.hh"
# include "hpp/statistics/bin.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