FFaUnitCalculator.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_UNIT_CALCULATOR_H
#define FFA_UNIT_CALCULATOR_H
 
#include <string>
#include <vector>
#include <map>
 
#include "FFaLib/FFaPatterns/FFaSingelton.H"
 
 
class FFaUnitCalculator
{
  struct SingleUnit
  {
    double factor = 1.0;  
    std::string origUnit; 
    std::string convUnit; 
  };
 
  using SingleUnitMap  = std::map<std::string,SingleUnit>;
  using SingleUnitIter = SingleUnitMap::const_iterator;
 
public:
  explicit FFaUnitCalculator(const char* n = NULL)
    : name(n ? n : ""), origGroup("SI"), convGroup("SI") {}
 
  bool isValid() const { return !name.empty(); }
 
  bool operator==(const FFaUnitCalculator& cal) const;
 
  const std::string& getName()      const { return name; }
  const std::string& getOrigUnits() const { return origGroup; }
  const std::string& getConvUnits() const { return convGroup; }
 
  template <class T> bool convert(T& value, const std::string& aName) const
  {
    SingleUnitIter it = myConvFactors.find(aName);
    if (it == myConvFactors.end()) return false;
 
    value *= it->second.factor;
    return true;
  }
 
  bool convert(double& value, const std::string& aName, int prec) const;
 
  template <class T> bool inverse(T& value, const std::string& aName) const
  {
    SingleUnitIter it = myConvFactors.find(aName);
    if (it == myConvFactors.end()) return false;
 
    value /= it->second.factor;
    return true;
  }
 
  double convFactor(const std::string& aName) const
  {
    SingleUnitIter it = myConvFactors.find(aName);
    return it == myConvFactors.end() ?  0.0 : it->second.factor;
  }
 
  std::string origUnitName(const std::string& aName) const
  {
    SingleUnitIter it = myConvFactors.find(aName);
    return it == myConvFactors.end() ? std::string("") : it->second.origUnit;
  }
 
  std::string convUnitName(const std::string& aName) const
  {
    SingleUnitIter it = myConvFactors.find(aName);
    return it == myConvFactors.end() ? std::string("") : it->second.convUnit;
  }
 
  void addConversion(const std::string& propName, double sf,
             const std::string& origUnit = "",
             const std::string& convUnit = "");
 
private:
  std::string name;      
  std::string origGroup; 
  std::string convGroup; 
  SingleUnitMap myConvFactors; 
 
  friend std::ostream& operator<< (std::ostream&, const FFaUnitCalculator&);
  friend std::istream& operator>> (std::istream&, FFaUnitCalculator&);
};
 
 
class FFaUnitCalculatorProvider : public FFaSingelton<FFaUnitCalculatorProvider>
{
  FFaUnitCalculatorProvider() {}
  virtual ~FFaUnitCalculatorProvider() {}
 
  friend class FFaSingelton<FFaUnitCalculatorProvider>;
 
public:
  const FFaUnitCalculator* getCalculator(const std::string& calcName) const;
  std::vector<const FFaUnitCalculator*> getCalculators() const;
 
  void getCalculatorNames(std::vector<std::string>& definedCalcs) const;
 
  void addCalculator(const FFaUnitCalculator& c) { myCalcs[c.getName()] = c; }
 
  bool readCalculatorDefs(const std::string& filename);
  bool printCalculatorDefs(const std::string& filename) const;
 
private:
  std::map<std::string,FFaUnitCalculator> myCalcs; 
};
 
#endif