FFaOperation.H

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 SAP SE
//
// SPDX-License-Identifier: Apache-2.0
//
// This file is part of FEDEM - https://openfedem.org
 
#ifndef FFA_OPERATION_H
#define FFA_OPERATION_H
 
#include <map>
#include <vector>
#include <string>
 
#include "FFaLib/FFaDynCalls/FFaDynCB.H"
#ifdef FT_USE_MEMPOOL
#include "FFaLib/FFaPatterns/FFaMemPool.H"
#endif
 
 
class FFaOperationBase
{
protected:
  FFaOperationBase() { myRefCount = 0; }
  virtual ~FFaOperationBase() {}
 
public:
  void ref() { myRefCount++; }
  void unref() { if (--myRefCount <= 0) delete this; }
 
#ifdef FT_USE_MEMPOOL
  static void freeMemPools() { getMemPoolMgr()->freeMemPools(); }
  static FFaMemPoolMgr* getMemPoolMgr()
  {
    static FFaMemPoolMgr memPools;
    return &memPools;
  }
#else
  static void freeMemPools() {}
#endif
 
private:
  short int myRefCount; 
};
 
 
template <class RetType>
class FFaOperation : public FFaOperationBase
{
protected:
  FFaOperation() : IAmEvaluated(false) {}
  virtual ~FFaOperation() {}
 
public:
  bool invoke(RetType& value)
  {
    bool ok = true;
    if (IAmEvaluated)
      value = myCachedValue;
    else
    {
      ok = this->evaluate(value);
      myCachedValue = value;
      IAmEvaluated = true;
    }
 
    return ok;
  }
 
  virtual void invalidate() { IAmEvaluated = false; }
 
  virtual bool hasData() const = 0;
  virtual bool evaluate(RetType& value) = 0;
 
private:
  RetType myCachedValue; 
 
protected:
  bool IAmEvaluated; 
};
 
template <> inline
FFaOperation<int>::FFaOperation() : myCachedValue(0), IAmEvaluated(false) {}
 
template <> inline
FFaOperation<float>::FFaOperation() : myCachedValue(0), IAmEvaluated(false) {}
 
template <> inline
FFaOperation<double>::FFaOperation() : myCachedValue(0), IAmEvaluated(false) {}
 
 
template <class OperationCB>
class FFaOperationContainer
{
  typedef std::map<std::string,OperationCB> OperCBMap;
 
public:
  static void addOperation(const std::string& name, OperationCB operation)
  {
    static std::map<std::string,OperationCB> ops;
    ops[name] = operation;
    ourOperations = &ops;
  }
 
  static void getOperations(std::vector<std::string>& names)
  {
    names.clear();
    if (ourOperations)
    {
      names.reserve(ourOperations->size());
      for (const typename OperCBMap::value_type& oper : *ourOperations)
        names.push_back(oper.first);
    }
  }
 
  static void setDefaultOperation(const std::string& o) { ourDefaultOper = o; }
  static const std::string& getDefaultOperation() { return ourDefaultOper; }
 
protected:
  FFaOperationContainer() { this->selectOperation(ourDefaultOper); }
 
  void selectOperation(const std::string& name)
  {
    if (ourOperations && !name.empty())
    {
      typename OperCBMap::const_iterator it = ourOperations->find(name);
      if (it != ourOperations->end())
      {
        myOperationCB = it->second;
        return;
      }
    }
 
    // The selected operation is not defined
    myOperationCB.erase();
  }
 
  OperationCB myOperationCB; 
 
private:
  static std::map<std::string,OperationCB>* ourOperations;
  static std::string ourDefaultOper;
};
 
template <class OperationCB>
std::map<std::string,OperationCB>* FFaOperationContainer<OperationCB>::ourOperations = NULL;
 
template <class OperationCB>
std::string FFaOperationContainer<OperationCB>::ourDefaultOper;
 
 
template <class RetType, class PrmType = RetType>
class FFaUnaryOp : public FFaOperation<RetType>,
                   public FFaOperationContainer< FFaDynCB2<RetType&,const PrmType&> >
{
public:
  FFaUnaryOp(FFaOperation<PrmType>* param, const std::string& name = "")
  {
    if ((myParam = param))
      myParam->ref();
 
    if (!name.empty())
      this->selectOperation(name);
  }
 
  virtual void invalidate()
  {
    if (this->IAmEvaluated && myParam)
      myParam->invalidate();
 
    this->IAmEvaluated = false;
  }
 
  virtual bool hasData() const
  {
    return myParam ? myParam->hasData() : false;
  }
 
  virtual bool evaluate(RetType& value)
  {
    bool ok = false;
    if (myParam && !this->myOperationCB.empty())
    {
      PrmType param;
      ok = myParam->invoke(param);
      this->myOperationCB.invoke(value,param);
    }
 
    return ok;
  }
 
protected:
  virtual ~FFaUnaryOp()
  {
    if (myParam) myParam->unref();
  }
 
private:
  FFaOperation<PrmType>* myParam; 
 
#ifdef FT_USE_MEMPOOL
  FFA_MAKE_MEMPOOL;
#endif
};
 
#ifdef FT_USE_MEMPOOL
template <class RetType, class PrmType>
FFaMemPool FFaUnaryOp<RetType,PrmType>::ourMemPool = FFaMemPool(sizeof(FFaUnaryOp<RetType,PrmType>),
                                                                FFaOperationBase::getMemPoolMgr());
#endif
 
 
template <class RetType>
class FFaNToOneOp : public FFaOperation<RetType>,
                    public FFaOperationContainer< FFaDynCB2<RetType&,const std::vector<RetType>&> >
{
public:
  FFaNToOneOp(const std::vector<FFaOperation<RetType>*>& params,
              const std::string& name = "")
  {
    myParams = params;
    for (FFaOperation<RetType>* p : myParams)
      if (p) p->ref();
 
    if (!name.empty())
      this->selectOperation(name);
  }
 
  virtual void invalidate()
  {
    if (this->IAmEvaluated)
      for (FFaOperation<RetType>* p : myParams)
        if (p) p->invalidate();
 
    this->IAmEvaluated = false;
  }
 
  virtual bool hasData() const
  {
    for (FFaOperation<RetType>* p : myParams)
      if (p && p->hasData())
        return true;
 
    return false;
  }
 
  virtual bool evaluate(RetType& value)
  {
    bool ok = !this->myOperationCB.empty();
    if (ok)
    {
      std::vector<RetType> pVals(myParams.size());
      for (size_t i = 0; i < myParams.size(); i++)
        if (myParams[i])
          ok &= myParams[i]->invoke(pVals[i]);
 
      this->myOperationCB.invoke(value,pVals);
    }
 
    return ok;
  }
 
protected:
  virtual ~FFaNToOneOp()
  {
    for (FFaOperation<RetType>* p : myParams)
      if (p) p->unref();
  }
 
private:
  std::vector<FFaOperation<RetType>*> myParams; 
 
#ifdef FT_USE_MEMPOOL
  FFA_MAKE_MEMPOOL;
#endif
};
 
#ifdef FT_USE_MEMPOOL
template <class RetType>
FFaMemPool FFaNToOneOp<RetType>::ourMemPool = FFaMemPool(sizeof(FFaNToOneOp<RetType>),
                                                         FFaOperationBase::getMemPoolMgr());
#endif
 
 
namespace FFa
{
  void setSpecialResultValue(double value, double equiv);
}
 
#endif