gmDiscontinuityAccessor.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_DISCONTINUITY_ACCESSOR_H_
#define _GEMA_DISCONTINUITY_ACCESSOR_H_

#include "gmAccessorProxy.h"

#include "gmDiscontinuity.h"
#include "gmSegmentCellIntersection.h"

#include <unitConverter.h>


#include <assert.h>


class GMC_API_EXPORT GmDiscontinuityAccessor : public GmAccessorProxy
{
public:
  GmDiscontinuityAccessor(GmValueAccessor* ac) : GmAccessorProxy(ac) {}

  // Wrapped functions.  For descriptions, see GmValueAccessor documentation
  const double* value(const GmDiscontinuity* d) const
  { 
    return _ac->value(queryIndex(d));
  }
  
  double scalarValue(const GmDiscontinuity* d) const
  { 
    return _ac->scalarValue(queryIndex(d));
  }

  void matrixValue(const GmDiscontinuity* d, GmCRMatrix& mat) const
  {
    _ac->matrixValue(queryIndex(d), mat);
  }

  void vectorValue(const GmDiscontinuity* d, GmCRVector& vec) const
  {
    _ac->vectorValue(queryIndex(d), vec);
  }

  bool setValue           (const GmDiscontinuity* d, const double* value)                   { return _ac->setValue(queryIndex(d), value); }
  bool setScalarValue     (const GmDiscontinuity* d, double value)                          { return _ac->setScalarValue(queryIndex(d), value); }
  bool setScalarValueAtDim(const GmDiscontinuity* d, int dim, double value)                 { return _ac->setScalarValueAtDim(queryIndex(d), dim, value); }
  bool setValueAsDef      (const GmDiscontinuity* d)                                        { return _ac->setValueAsDef(queryIndex(d)); }
  bool setFunctionValue   (const GmDiscontinuity* d, GmUserFunction* functionDef)           { Q_UNUSED(d); Q_UNUSED(functionDef);  return logUserFunctionError(); }
  bool setFunctionValue   (const GmDiscontinuity* d, GmUserFunctionEvaluator* functionEval) { Q_UNUSED(d); Q_UNUSED(functionEval); return logUserFunctionError(); }

  QString valueStr(const GmDiscontinuity* d, bool evalFunctions, bool printDefAsNil,
                   int fieldWidth = 0, char format = 'g', int precision = -1) const
  {
    return _ac->valueStr(queryIndex(d), evalFunctions, printDefAsNil, fieldWidth, format, precision, NULL);
  }

  bool setFunctionFromName(const GmDiscontinuity* d, QString userFunctionId, QString& err)
  {
    Q_UNUSED(d); Q_UNUSED(userFunctionId);
    err = QObject::tr("Discontinuity accessor does not accept function values.");
    return false;
  }

  bool setValueFromVariant(const GmDiscontinuity* d, const QVariant& v, bool acceptMissingDimension, QString& err)
  {
    return _ac->setValueFromVariant(queryIndex(d), v, acceptMissingDimension, err);
  }

  bool    isDefValue(const GmDiscontinuity* d) const { return _ac->isDefValue(queryIndex(d)); }
  bool    isFunction(const GmDiscontinuity* d) const { return _ac->isFunction(queryIndex(d)); }
  QString functionId(const GmDiscontinuity* d) const { return _ac->functionId(queryIndex(d)); }

protected:
  bool logUserFunctionError()
  {
    // We can only log a message if the accessor is a GmValueAccessorBase instance
    GmValueAccessorBase* bac = dynamic_cast<GmValueAccessorBase*>(_ac);
    if(bac)
      gmWarnMsg(bac->_logger, QObject::tr("Discontinuity accessor does not accept function values."));
    return false;
  }

  virtual int queryIndex(const GmDiscontinuity* d) const = 0;
};

class GMC_API_EXPORT GmAttributeDiscontinuityAccessor : public GmDiscontinuityAccessor
{
public:
  GmAttributeDiscontinuityAccessor(GmValueAccessor* ac) : GmDiscontinuityAccessor(ac) {}

protected:
  virtual int queryIndex(const GmDiscontinuity* d) const { assert(d); return d->index(); }
};

class GMC_API_EXPORT GmPropertyDiscontinuityAccessor : public GmDiscontinuityAccessor
{
public:
  GmPropertyDiscontinuityAccessor(GmValueAccessor* ac, int psetIndex) : GmDiscontinuityAccessor(ac), _pset(psetIndex) {}

protected:
  virtual int queryIndex(const GmDiscontinuity* d) const { assert(d); return d->propertyIndex(_pset); }

private:
  int _pset; 
};


class GMC_API_EXPORT GmSegmentCell2DIntersectionCoordAccessor
{
public:
  GmSegmentCell2DIntersectionCoordAccessor(int dim, UnitConverter* conv, QString desiredUnit)
    : _dim(dim), _unit(desiredUnit), _conv(conv), _convData(NULL)
  {
    if(conv)
      _convData = new GmTLBuffer<double, true>(dim);
  }

  ~GmSegmentCell2DIntersectionCoordAccessor()
  {
    delete _conv;
    delete _convData;
  }

  Unit unit() const { return Unit(_unit); }

  bool hasUnitConversion() const { return _conv; }

  int valueSize() const { return _dim; }

  const double* value(const GmCompact2DSegmentCellIntersection* ci, int i) const
  {
    const double* p = ci->rawCartCoord(i);
    return _conv ? _conv->convertArray(p, _dim, _convData->localBuffer()) : p;
  }

  void vectorValue(const GmCompact2DSegmentCellIntersection* ci, int i, GmCRVector& vec) const
  {
    vec.setMemory(value(ci, i), valueSize());
  }

private:
  int                               _dim;      
  QString                           _unit;     
  UnitConverter*                    _conv;     
  mutable GmTLBuffer<double, true>* _convData; 
};



#endif