JHistory.hh

Go to the documentation of this file.

#ifndef __JFIT__JHISTORY__
#define __JFIT__JHISTORY__
 
#include <istream>
#include <ostream>
#include <iomanip>
#include <vector>
#include <algorithm>
 
#include <TROOT.h>
#include <TObject.h>
 
#include "JROOT/JRoot.hh"
#include "JLang/Jpp.hh"
#include "JLang/JPredicate.hh"
#include "JSystem/JDate.hh"
#include "JFit/JFitApplications.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JFIT {}
namespace JPP { using namespace JFIT; }
 
namespace JFIT {
  
  /**
   * Auxiliary class for historical event.
   */
  struct JEvent {
    /**
     * Default constructor.
     */
    JEvent() :
      type(-1),
      id  (-1)
    {}
 
    /**
     * Constructor.
     *
     * \param  type          application type
     * \param  id            application identifier
     */
    JEvent(const int type,
           const int id)
    {
      this->type = type;
      this->id   = id;
      this->svn  = JLANG::getGITVersion();
      this->date = JSYSTEM::getDateAndTime();
    }  
 
 
    /**
     * Virtual destructor.
     */
    virtual ~JEvent() 
    {}
 
    
    /**
     * Write event to output stream.
     *
     * \param  out           output stream
     * \param  event         event
     * \return               output stream
     */
    friend std::ostream& operator<<(std::ostream& out, const JEvent& event)
    {
      using namespace std;
      
      out << setw(3)  << right << event.id   << ' '
          << setw(2)  << right << event.type << ' '
          << setw(20) << left  << event.svn  << ' '
          << setw(20) << left  << event.date;
 
      return out;
    }
 
    ClassDef(JEvent, 1);
    
    int type;               ///< application type
    int id;                 ///< application identifier
    std::string svn;        ///< SVN revision
    std::string date;       ///< date
  };
 
 
  /**
   * Container for historical events.
   */
  struct JHistory :
    public std::vector<JEvent>
  {
    /**
     * Auxiliary class to test history.
     */
    struct is_event {
      /**
       * Constructor.
       *
       * \param  type          application type
       */
      is_event(int type)
      {
        this->type = type;
      }
 
 
      /**
       * Constructor.
       *
       * \param  history       history
       */
      is_event(const JHistory& history)
      {
        if (!history.empty())
          this->type = history.rbegin()->type;
        else
          this->type = -1;
      }
 
 
      /**
       * Test history.
       *
       * \param  history       history
       * \return               true if given history ends with specified event type; else false
       */
      bool operator()(const JHistory& history) const
      {
        if (!history.empty()) {
          return history.rbegin()->type == this->type;
        }
 
        return false;
      }
 
      int type;
    };
 
 
    /**
     * Auxiliary class to test history.
     */
    struct is_not_event {
      /**
       * Constructor.
       *
       * \param  type          application type
       */
      is_not_event(int type)
      {
        this->type = type;
      }
 
 
      /**
       * Test history.
       *
       * \param  history       history
       * \return               true if given history does not contain specified event type; else false
       */
      bool operator()(const JHistory& history) const
      {
        using namespace std;
        using namespace JLANG;
        
        return count_if(history.begin(), history.end(), make_predicate(&JEvent::type, this->type)) == 0;
      }
      
      int type;
    };
 
 
    /**
     * Default constructor.
     */
    JHistory() :
      std::vector<JEvent>()
    {}
    
    
    /**
     * Constructor.
     *
     * \param  type          application type
     */
    JHistory(const int type) :
      std::vector<JEvent>()
    {
      add(type);
    }
    
    
    /**
     * Constructor.
     *
     * \param  history       history
     * \param  type          application type
     */
    JHistory(const JHistory&          history,
             const int type) :
      std::vector<JEvent>(history)
    {
      add(type);
    }
 
 
    /**
     * Virtual destructor.
     */
    virtual ~JHistory() 
    {}
 
 
    /**
     * Get history.
     *
     * \return               histtory
     */
    const JHistory& getHistory() const
    {
      return static_cast<const JHistory&>(*this);
    }
 
 
    /**
     * Get history.
     *
     * \return               histtory
     */
    JHistory& getHistory() 
    {
      return static_cast<JHistory&>(*this);
    }
 
    
    /**
     * Add event to history.
     *
     * \param  type          application type
     * \return               this history
     */
    JHistory& add(const int type)
    {
      push_back(JEvent(type, this->size() + 1));
 
      return *this;
    }
    
    
    /**
     * Write history to output stream.
     *
     * \param  out           output stream
     * \param  history       history
     * \return               output stream
     */
    friend std::ostream& operator<<(std::ostream& out, const JHistory& history)
    {
      using namespace std;
      
      for (const_iterator i = history.begin(); i != history.end(); ++i) {
        out << *i << endl;
      }
 
      return out;
    }
 
    ClassDef(JHistory, 1);
  };
}
 
#endif