JHistory.hh

Go to the documentation of this file.

#ifndef __JRECONSTRUCTION__JHISTORY__
#define __JRECONSTRUCTION__JHISTORY__
 
#include <istream>
#include <ostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <random>
#include <limits>
 
#include <TObject.h>
 
#include "km3net-dataformat/definitions/fitparameters.hh"
 
#include "JLang/Jpp.hh"
#include "JLang/JUUID.hh"
#include "JLang/JPredicate.hh"
#include "JSystem/JDateAndTime.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JRECONSTRUCTION {}
namespace JPP { using namespace JRECONSTRUCTION; }
 
namespace JFIT {
 
  using JLANG::JUUID;
  
  /**
   * Auxiliary class for historical event.
   */
  struct JEvent {
    /**
     * Default constructor.
     */
    JEvent() :
      type(-1),
      uuid()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  type          application type
     */
    JEvent(const int type)
    {
      using namespace std;
      using namespace JPP;
 
      this->type = type;
      this->git  = getGITVersion();
      this->date = getDateAndTime();
 
      // UUID
 
      random_device device;
 
      uniform_int_distribution<uint32_t> generator(1, numeric_limits<uint32_t>::max());
 
      uint32_t* value = reinterpret_cast<uint32_t*>(&(this->uuid.uuid));
 
      for (int i = 0; i != 3; ++i) {
        value[i] = generator(device);
      }
    }  
 
 
    /**
     * Virtual destructor.
     */
    virtual ~JEvent() 
    {}
 
 
    /**
     * Make this event unique.
     *
     * \return               event
     */
    const JEvent& operator()()
    {
      uint32_t* value = reinterpret_cast<uint32_t*>(&(this->uuid.uuid));
 
      value[3] = ++counter;
 
      return *this;
    }
 
 
    /**
     * 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.type << ' '
          << setw(36) << left  << event.uuid << ' '
          << setw(20) << left  << event.git  << ' '
          << setw(20) << left  << event.date << right;
 
      return out;
    }
 
    ClassDef(JEvent, 2);
    
    int         type;       ///< application type
    JUUID       uuid;       ///< UUID
    std::string git;        ///< GIT revision
    std::string date;       ///< date
    uint32_t    counter = 0;//!< internal counter
  };
 
 
  /**
   * Container for historical events.
   */
  struct JHistory :
    public std::vector<JEvent>
  {
    /**
     * Auxiliary class to test history.
     */
    struct is_event :
      public std::vector<int>
    {
      /**
       * Constructor.
       *
       * \param  history       history
       */
      is_event(const JHistory& history)
      {
        for (JHistory::const_iterator i = history.begin(); i != history.end(); ++i) {
          this->push_back(i->type);
        }
      }
 
 
      /**
       * Test history.
       *
       * \param  history       history
       * \return               true if given history same as this history; else false
       */
      bool operator()(const JHistory& history) const
      {
        return history.getStatus(*this);
      }
    };
 
 
    /**
     * Auxiliary class to test history.
     */
    struct is_application
    {
      /**
       * Constructor.
       *
       * \param  type          application type
       */
      is_application(int type) :
        type(type)
      {}
 
 
      /**
       * Test history.
       *
       * \param  history       history
       * \return               true if given history ends with this application type; else false
       */
      bool operator()(const JHistory& history) const
      {
        return !history.empty() && history.rbegin()->type == this->type;
      }
 
      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 JPP;
        
        return count_if(history.begin(), history.end(), make_predicate(&JEvent::type, this->type)) == 0;
      }
      
      int type;
    };
 
 
    /**
     * Default constructor.
     */
    JHistory() :
      std::vector<JEvent>()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  event         event
     */
    JHistory(const JEvent& event) :
      std::vector<JEvent>(1, event)
    {}
    
 
    /**
     * Constructor.
     *
     * \param  type          application type
     */
    JHistory(const int type) :
      std::vector<JEvent>(1, JEvent(type))
    {}
 
 
    /**
     * Constructor.
     *
     * \param  history       history
     * \param  event         event
     */
    JHistory(const JHistory& history,
             const JEvent&   event) :
      std::vector<JEvent>(history)
    {
      push_back(event);
    }
 
 
    /**
     * 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);
    }
 
 
    /**
     * Has event in history.
     *
     * \param  type          application type
     * \return               true if given event in history; else false
     */
    bool has(const int type) const
    {
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        if (i->type == type) {
          return true;
        }
      }
 
      return false;
    }
 
 
    /**
     * Get status.
     *
     * \param  types         application types
     * \return               true if history matches appplication types; else false
     */
    bool getStatus(const std::vector<int>& types) const
    {
      if (this->size() == types.size()) {
 
        for (size_t i = 0; i != this->size(); ++i) {
          if ((*this)[i].type != types[i]) {
            return false;
          }
        }
 
        return true;
 
      } else {
 
        return false;
      }
    }
 
 
    /**
     * Add event to history.
     *
     * \param  type          application type
     * \return               this history
     */
    JHistory& add(const int type)
    {
      push_back(JEvent(type));
 
      return *this;
    }
 
 
    /**
     * Has parent UUID.
     */
    bool hasParentUUID() const
    {
      return this->size() >= 2u;
    }
 
 
    /**
     * Get UUID.
     */
    const JUUID& getUUID() const
    {
      return this->at(this->size() - 1).uuid;
    }
 
 
    /**
     * Get parent UUID.
     */
    const JUUID& getParentUUID() const
    {
      return this->at(this->size() - 2).uuid;
    }
    
 
    /**
     * 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, 2);
  };
}
 
namespace JRECONSTRUCTION {
  typedef JFIT::JEvent     JEvent;
  typedef JFIT::JHistory   JHistory;
}
 
#endif