gmResultDataSrc.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together 
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND, 
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR 
** A PARTICULAR PURPOSE.
**
************************************************************************/

#ifndef _GEMA_RESULT_DATASRC_H_
#define _GEMA_RESULT_DATASRC_H_

#include "gmResultDataSrcInfo.h"

#include "gmInterpolator.h"
#include "gmValueAccessor.h"
#include "gmCellAccessor.h"
#include "gmGaussAccessor.h"

#include <luaFunction.h>
#include <unitConverter.h>


class GMC_API_EXPORT GmAttributeResultDataSrc : public GmResultDataSrcInfo
{
public:
  GmAttributeResultDataSrc(int trackId, GmResultDataSrcType type, QString name, Unit unit)
    : _trackId(trackId), _type(type), _alias(name), _unit(unit), _info(NULL), _id(-1), _conv(NULL) {}

  virtual ~GmAttributeResultDataSrc() { delete _conv; }

  bool setInfo(const GmAttributeResultDataSrcInfo* info, int id)
  {
    assert(info);
    assert(info->type()  == _type);
    assert(info->alias() == _alias);

    if(_unit.name().isEmpty()) // If the user didn't gave a unit, the result will be on _info unit.
      _unit = info->unit();
    else
    {
      bool compatibleUnits;
      _conv = Unit::converter(info->unit(), _unit, &compatibleUnits);
      if(!compatibleUnits)
        return false;  // We don't know how to convert from _info->unit() to _unit.
    }

    _info = info;
    _id   = id;
    return true;
  }

  virtual int                 trackId()     const { return _trackId; }
  virtual GmResultDataSrcType type()        const { return _type;  }
  virtual QString             alias()       const { return _alias; }
  virtual Unit                unit()        const { return _unit;  }
  virtual QString             description() const { return _info ? _info->description() : ""; }
  virtual int                 size()        const { return _info ? _info->size() : -1;        }
  virtual int                 nlin()        const { return _info ? _info->nlin() : -1;        }
  virtual int                 ncol()        const { return _info ? _info->ncol() : -1;        }
  virtual QString             formatStr()   const { return _info ? _info->formatStr() : "";   }

  int            resultId()      const { return _id; }
  UnitConverter* unitConverter() const { return _conv; }

private:
  Q_DISABLE_COPY(GmAttributeResultDataSrc);

  int                                 _trackId; 
  GmResultDataSrcType                 _type;  
  QString                             _alias; 
  Unit                                _unit;  
  const GmAttributeResultDataSrcInfo* _info;  
  int                                 _id;    
  UnitConverter*                      _conv;  
};


class GMC_API_EXPORT GmResultAcDataSrcBase : public GmResultDataSrcInfo
{
public:

  GmResultAcDataSrcBase(int trackId)
    : _trackId(trackId), _dim(-1), _history(0), _interpType(GM_DEFAULT_INTERPOLATOR),
      _nResLin(0), _nResCol(0), _interp(NULL) {}

  virtual GmResultAcDataSrcBase::~GmResultAcDataSrcBase() { delete _interp; }

  // Comments on the base class
  virtual int trackId() const { return _trackId; }

  // Returns the accessor id
  virtual QString id() const = 0;

  // Comments on the base class
  virtual QString alias() const { return _alias; }

  // Comments on the base class
  virtual QString formatStr() const { return _formatStr; }

  virtual bool isScalar() const = 0;

  virtual int dimSize() const = 0;

  int history() const { return _history; }

  int dimFilter() const { return _dim; }

  void setBasicData(int dim, const QString& alias, int history,
    GmInterpolatorType interpType, const QVariant& interpParam)
  {
    _dim         = dim;
    _alias       = alias;
    _history     = history;
    _interpType  = interpType;
    _interpParam = interpParam;
  }

  void setFormatStr(const QString& formatStr) { _formatStr = formatStr; }

  void setTransformationFunction(LuaFunction& tfunc, int nresLin, int nresCol)
  {
    _tFunc = tfunc;
    _tFunc.makeRef();  // Ensure that tFunc stores a function reference and not a stack index
    _nResLin = nresLin;
    _nResCol = nresCol;
  }

  void setInterpolator(GmInterpolator* interp) { delete _interp; _interp = interp; }

protected:
  friend class GmResultsRule; // Give full acces to the results rule class

  Q_DISABLE_COPY(GmResultAcDataSrcBase);

  GmResultAcDataSrcBase(const GmResultAcDataSrcBase* ptr)
  {
    assert(!ptr->_interp);

    _interpType  = GM_DEFAULT_INTERPOLATOR;
    _interp      = NULL;
    _interpParam = QVariant();

    _trackId   = ptr->_trackId;
    _alias     = ptr->_alias;
    _dim       = ptr->_dim;
    _formatStr = ptr->_formatStr;
    _history   = ptr->_history;
    _tFunc     = ptr->_tFunc;   
    _nResLin   = ptr->_nResLin;
    _nResCol   = ptr->_nResCol;
  }

  int                _trackId;     
  QString            _alias;       
  int                _dim;         
  QString            _formatStr;   
  int                _history;     
  GmInterpolatorType _interpType;  
  QVariant           _interpParam; 
  LuaFunction        _tFunc;       
  int                _nResLin;     
  int                _nResCol;     
  GmInterpolator*    _interp;      
};

template <class T>
class GMC_API_EXPORT GmResultAcDataSrc : public GmResultAcDataSrcBase
{
public:
  // The stored accessr type
  typedef T AcType;

  GmResultAcDataSrc(int trackId, T* ac) : GmResultAcDataSrcBase(trackId) { assert(ac); _ac = ac; _ownership = true; }

  virtual ~GmResultAcDataSrc() { if(_ownership) delete _ac; }

  // Comments on the base class
  virtual QString id() const { return _ac->info()->id(); }

  // Comments on the base class
  virtual QString description() const { return _ac->info()->description(); }

  // Comments on the base class
  virtual Unit unit() const { return _ac->unit(); }

  // Comments on the base class
  virtual bool isScalar() const { return _dim >= 0 || _ac->isScalar(); }

  // Comments on the base class
  virtual int dimSize() const { return _dim == -1 ? _ac->valueSize() : 1; }

  // Comments on the base class
  virtual int size() const { return _tFunc.isValid() ? _nResLin * _nResCol : dimSize(); }

  // Comments on the base class
  virtual int nlin() const { return _tFunc.isValid() ? _nResLin : (_dim == -1 ? _ac->info()->nlin() : 1); }

  // Comments on the base class
  virtual int ncol() const { return _tFunc.isValid() ? _nResCol : (_dim == -1 ? _ac->info()->ncol() : 1); }

  T* ac() const { return _ac; }

  void setAc(T* newAc) { if(_ownership) delete _ac; _ac = newAc; _ownership = true; }

protected:
  
  template <class Result>
  QVector<Result*> dimSplit() 
  { 
    assert(dynamic_cast<Result*>(this)); // Result should realy be the same type as this!!!

    QVector<Result*> list;
    list.append(dynamic_cast<Result*>(this)); 

    if(!isScalar())
    {
      for(int i = 1, ndim = _ac->valueSize(); i < ndim; i++)
      {
        Result* r = new Result(this);
        r->_dim = i;
        r->_alias = r->_alias + QString("_%1").arg(i+1);
        list.append(r);
      }
      _dim = 0;
      _alias = _alias + QString("_%1").arg(1); // Can't be done before the loop or the copy would already include the dimension suffix
    }
    return list;
  }

  GmResultAcDataSrc(const GmResultAcDataSrc<T>* ptr) 
    : GmResultAcDataSrcBase(ptr)
  {
    _ac        = ptr->_ac;
    _ownership = false;
  }

  T*   _ac;        
  bool _ownership; 
};

class GMC_API_EXPORT GmResultNodeDataSrc : public GmResultAcDataSrc<GmValueAccessor>
{
public:
  GmResultNodeDataSrc(int trackId, GmValueAccessor* ac) : GmResultAcDataSrc<GmValueAccessor>(trackId, ac) {}

  // Comments on the base class
  virtual GmResultDataSrcType type() const { return GM_RR_DS_NODEDATA; }

  QVector<GmResultNodeDataSrc*> dimensionSplit() { return dimSplit<GmResultNodeDataSrc>(); }

private:
  friend QVector<GmResultNodeDataSrc*> GmResultAcDataSrc<GmValueAccessor>::dimSplit();

  GmResultNodeDataSrc(const GmResultAcDataSrc<GmValueAccessor>* base) : GmResultAcDataSrc<GmValueAccessor>(base) {};
};

class GMC_API_EXPORT GmResultCellDataSrc : public GmResultAcDataSrc<GmCellAccessor>
{
public:
  GmResultCellDataSrc(int trackId, GmCellAccessor* ac) : GmResultAcDataSrc<GmCellAccessor>(trackId, ac) {}

  virtual GmResultDataSrcType type() const { return GM_RR_DS_CELLDATA; }

  // Comments on the base class
  QVector<GmResultCellDataSrc*> dimensionSplit() { return dimSplit<GmResultCellDataSrc>(); }

private:
  friend QVector<GmResultCellDataSrc*> GmResultAcDataSrc<GmCellAccessor>::dimSplit();

  GmResultCellDataSrc(const GmResultAcDataSrc<GmCellAccessor>* base) : GmResultAcDataSrc<GmCellAccessor>(base) {};
};

class GMC_API_EXPORT GmResultGaussDataSrc : public GmResultAcDataSrc<GmGaussAccessor>
{
public:
  GmResultGaussDataSrc(int trackId, GmGaussAccessor* ac) : GmResultAcDataSrc<GmGaussAccessor>(trackId, ac) {}

  // Comments on the base class
  virtual GmResultDataSrcType type() const { return GM_RR_DS_GAUSSDATA; }

  QVector<GmResultGaussDataSrc*> dimensionSplit() { return dimSplit<GmResultGaussDataSrc>(); }

private:
  friend QVector<GmResultGaussDataSrc*> GmResultAcDataSrc<GmGaussAccessor>::dimSplit();

  GmResultGaussDataSrc(const GmResultAcDataSrc<GmGaussAccessor>* base) : GmResultAcDataSrc<GmGaussAccessor>(base) {};
};

#endif