measureitem.hpp

#ifndef DDF_MEASUREITEM_HPP
#define DDF_MEASUREITEM_HPP

#include <iostream>
#include "ddf/definitions.hpp"
#include "ddf/ctime.hpp"
#include "ddf/debugging.hpp"

namespace jafar
{
  namespace ddfsimu
  {
    using namespace jafar::ddf;
    
    class MeasureItem{

      VEC      m_data;        // The measurement vector
      time     m_sensed;      // time of acquisition
      time     m_available;   // time when the measurement has been processed
   
    public:

      MeasureItem(unsigned short size);
      MeasureItem(MeasureItem const& item);
      ~MeasureItem();

      void ClearAll() {  m_sensed = time::null(); m_available = time::null(); m_data.clear(); }
      unsigned short GetSize() const { return m_data.size(); }
   
      void SetMeasure(time sens, time avail, VEC &data) {
        JFR_PRECOND(data.size() == m_data.size(), "bad sizes");
        m_sensed = sens;
        m_available = avail;
        m_data = data;
      }
      void GetMeasure(time *sens, time *avail, VEC *data) {
        JFR_PRECOND(data->size() == m_data.size(), "bad sizes");
        *sens = m_sensed;
        *avail = m_available;
        *data = m_data;
      }

      void GetMeasure(double *sens, double *avail, VEC *data) {
        JFR_PRECOND(data->size() == m_data.size(), "bad sizes");
        *sens = m_sensed.to_double();
        *avail = m_available.to_double();
        *data = m_data;
      }

      time const& GetSensedTime() const { return m_sensed; }
      double GetSensedTimeSec() const { return m_sensed.to_double(); }
      time const& GetAvailableTime() const { return m_available; }
      VEC const& GetDataOnly() const { return m_data; }
      MeasureItem & operator =(MeasureItem const &item) {
        JFR_PRECOND(m_data.size() == item.m_data.size(), "bad sizes");
        if (&item == this) return *this;
        m_data = item.m_data;
        m_sensed = item.m_sensed;
        m_available = item.m_available;
        return *this;
      }

      int compare_sensed(MeasureItem const& other) const;
      int compare_available(MeasureItem const& other) const;
      bool equal_sensed(MeasureItem const& other) const { return !compare_sensed(other); }
      bool equal_available(MeasureItem const& other) const { return !compare_available(other); }
      bool operator == (const MeasureItem& other) const;
   
      friend std::ostream& operator << (std::ostream &stream, MeasureItem const& other);
    };

    std::ostream& operator << (std::ostream &stream, MeasureItem const& other);

  } // namespace ddfsimu
} // namespace jafar
#endif