plotinstance.h

//
// author Kazys Stepanas
//
// Copyright (c) CSIRO 2015
//
#ifndef PLOTINSTANCE_H_
#define PLOTINSTANCE_H_

#include "plotsconfig.h"

#include "plotsource.h"

#include <QColor>
#include <QMutex>
#include <QPointF>
#include <QString>

#include <cstdint>
#include <vector>

class PlotDataCurve;
class PointSeriesData;
class PlotExpression;

class PlotInstance
{
public:
  enum Flag
  {
    DataComplete = (1 << 0),
    RingBuffer = (1 << 1),
    ExplicitColour = (1 << 2),
    FilterNaN = (1 << 3),
    FilterInf = (1 << 4),
    ExplicitTime = (1 << 5),
  };

  enum Defaults
  {
    DefaultSymbolSize = 5   
  };

  PlotInstance(const PlotSource::Ptr &source);

  PlotInstance(const PlotInstance &other);

  ~PlotInstance();

  PlotSource &source();

  const PlotSource &source() const;

  void setDefaultProperties();

  inline QString name() const { return _name; }

  inline void setName(QString name) { _name = name; }

  inline int style() const { return _style; }

  inline void setStyle(unsigned style) { _style = std::int8_t(style); }

  inline unsigned width() const { return _width; }

  inline void setWidth(unsigned width) { _width = std::uint8_t(width); }

  inline int symbol() const { return _symbol; }

  inline void setSymbol(int symbol) { _symbol = std::int8_t(symbol); }

  inline unsigned symbolSize() const { return _symbolSize; }

  inline void setSymbolSize(unsigned size) { _symbolSize = std::uint8_t(size); }

  inline const std::vector<QPointF> &data() const { return _data; }

  inline const QRgb &colour() const { return _colour; }

  void setColour(const QRgb &colour, bool markExplicit = true);

  inline const PlotExpression *expression() const { return _expression; }

  inline void setExpression(const PlotExpression *expression) { _expression = expression; }

  inline size_t ringHead() const { return _ringHead; }

  inline std::uint16_t flags() const { return _flags; }

  inline bool testFlags(std::uint16_t flags) { return (_flags & flags) == flags; }

  inline bool dataComplete() const { return (_flags & DataComplete) != 0; }

  inline void setComplete() { setFlagsState(DataComplete, true);  }

  inline bool isRingBuffer() const { return (_flags & RingBuffer) != 0; }

  void makeRingBuffer(size_t bufferSize);

  inline bool explicitColour() const { return (_flags & ExplicitColour) != 0; }

  inline bool filterNaN() const { return (_flags & FilterNaN) != 0; }

  inline void setFilterNaN(bool filter) { setFlagsState(FilterNaN, filter); }

  inline bool filterInf() const { return (_flags & FilterInf) != 0; }

  inline void setFilterInf(bool filter) { setFlagsState(FilterInf, filter); }

  inline bool explicitTime() const { return (_flags & ExplicitTime) != 0; }

  inline void setExplicitTime(bool explct) { setFlagsState(ExplicitTime, explct); }

  QPointF sample(size_t index) const;

  void addPoint(const QPointF &p);

  void addPoints(const QPointF *points, size_t pointCount);

  bool migrateBuffer();

  PlotInstance &operator=(const PlotInstance &other);

private:
  void setFlagsState(std::uint16_t flags, bool set);

  std::vector<QPointF> _data;  
  PlotSource::Ptr _source;  
  QString _name;       
  QRgb _colour;
  const PlotExpression *_expression; 
  size_t _ringHead;
  std::uint16_t _flags;     
  std::int8_t _style;       
  std::uint8_t _width;      
  std::int8_t _symbol;      
  std::uint8_t _symbolSize; 

  QMutex _mutex;
  std::vector<QPointF> _buffer;  
};


inline PlotSource &PlotInstance::source()
{
  return *_source;
}


inline const PlotSource &PlotInstance::source() const
{
  return *_source;
}


inline void PlotInstance::setColour(const QRgb &colour, bool markExplicit)
{
  _colour = colour;
  // Set ExplicitColour flag as requested.
  setFlagsState(ExplicitColour, markExplicit);
}


inline void PlotInstance::setFlagsState(std::uint16_t flags, bool set)
{
  _flags = (_flags & ~flags) | (!!set * flags);
}

#endif // PLOTINSTANCE_H_