FFaCmdLineArg.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_CMD_LINE_ARG_H
#define FFA_CMD_LINE_ARG_H
 
#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <cctype>
 
 
class FFaCmdLineEntryBase
{
protected:
  FFaCmdLineEntryBase(const std::string& text, bool showToAll)
    : myHelpText(text), iAmSetOnCmdLine(false), isPublic(showToAll) {}
 
public:
  virtual ~FFaCmdLineEntryBase() {}
  virtual bool hasValue() const = 0;
  virtual bool hasDefault() const = 0;
  virtual int convertOption(const std::string&) = 0;
  virtual std::string getDefaultString() const = 0;
  virtual std::string getValueString(bool = false) const = 0;
  virtual void reset() = 0;
 
protected:
  std::string myHelpText; 
  bool iAmSetOnCmdLine;   
  bool isPublic;          
 
  friend class FFaCmdLineArg;
};
 
 
template<class T> class FFaCmdLineEntry : public FFaCmdLineEntryBase
{
public:
  FFaCmdLineEntry(const std::string& text, const T& value, bool showToAll)
    : FFaCmdLineEntryBase(text,showToAll), myValue(value), myDefault(value) {}
  virtual ~FFaCmdLineEntry() {}
 
  virtual bool hasValue() const { return true; }
  virtual bool hasDefault() const { return true; }
 
  virtual int convertOption(const std::string&) { return -1; }
 
  virtual std::string getDefaultString() const
  {
    return this->toString(myDefault);
  }
 
  virtual std::string getValueString(bool noDefaults) const
  {
    if (noDefaults && !iAmSetOnCmdLine)
      return std::string();
 
    return this->toString(myValue);
  }
 
  const T& getValue() const { return myValue; }
 
  virtual void reset() { myValue = myDefault; iAmSetOnCmdLine = false; }
 
protected:
  virtual std::string toString(const T& value) const
  {
    std::stringstream sval;
    sval << value;
    return sval.str();
  }
 
private:
  T myValue;   
  T myDefault; 
};
 
 
class FFaCmdLineArg
{
  typedef std::map<std::string,FFaCmdLineEntryBase*> OptionMap;
 
private:
  FFaCmdLineArg();
  ~FFaCmdLineArg();
 
public:
  static void init(int argc, char** argv) { instance()->initArgs(argc,argv); }
  static bool empty();
  static FFaCmdLineArg* instance();
  static void removeInstance();
 
  template<class T> void addOption(const std::string& identifier,
                                   const T&           value,
                                   const std::string& helpText,
                                   bool showToAll = true)
  {
    // In case the same option is defined twice, avoid memory leak
    OptionMap::iterator it = myOptions.find(identifier);
    if (it != myOptions.end()) delete it->second;
 
    myOptions[identifier] = new FFaCmdLineEntry<T>(helpText,value,showToAll);
  }
 
  void addOption(const std::string& identifier,
                 const char*        value,
                 const std::string& helpText,
                 bool showToAll = true)
  {
    this->addOption(identifier,std::string(value),helpText,showToAll);
  }
 
  template<class T> bool getValue(const std::string& identifier, T& aVal)
  {
    this->evaluate();
 
    OptionMap::const_iterator opIt = myOptions.find(identifier);
    if (opIt != myOptions.end())
    {
      FFaCmdLineEntry<T>* obj = dynamic_cast<FFaCmdLineEntry<T>*>(opIt->second);
      if (obj)
      {
        aVal = obj->getValue();
        return true;
      }
    }
 
    if (!mute)
      std::cerr <<" *** Could not evaluate command-line option \""
                << identifier <<"\""<< std::endl;
    return false;
  }
 
  bool setValue(const std::string& identifier, const std::string& value);
 
  void composeHelpText(std::string& report, bool all = false) const;
  void composeSingleLineHelpText(std::string& report, bool all = false) const;
  void listOptions(bool noDefaults = false) const;
  bool isOptionSetOnCmdLine(const std::string& identifier);
  bool readOptionsFile(const std::string& fileName);
 
  static std::string additionalHelpText;
 
  static bool mute; 
 
private:
  void initArgs(int argc, char** argv);
  void evaluate();
 
  std::vector<std::string> myArgs;    
  OptionMap                myOptions; 
 
  static FFaCmdLineArg* myInstance; 
};
 
 
// Template specializations
 
typedef std::vector<int>    IntVec;    
typedef std::vector<double> DoubleVec; 
 
 
template<> inline
bool FFaCmdLineEntry<std::string>::hasValue() const
{
  return !myValue.empty();
}
 
template<> inline
bool FFaCmdLineEntry<std::string>::hasDefault() const
{
  return !myDefault.empty();
}
 
 
template<> inline
bool FFaCmdLineEntry<IntVec>::hasDefault() const
{
  return !myDefault.empty();
}
 
 
template<> inline
bool FFaCmdLineEntry<DoubleVec>::hasDefault() const
{
  return !myDefault.empty();
}
 
 
template<> inline
std::string FFaCmdLineEntry<std::string>::getDefaultString() const
{
  return myDefault;
}
 
template<> inline
std::string FFaCmdLineEntry<std::string>::getValueString(bool noDefaults) const
{
  if (noDefaults && myValue == myDefault)
    return std::string();
 
  return myValue;
}
 
 
template<> inline
std::string FFaCmdLineEntry<bool>::getDefaultString() const
{
  return std::string(myDefault ? "+ (true)" : "- (false)");
}
 
 
template<> inline
std::string FFaCmdLineEntry<bool>::getValueString(bool noDefaults) const
{
  if (noDefaults && myValue == myDefault)
    return std::string();
 
  return std::string(myValue ? "+ (true)" : "- (false)");
}
 
 
template<> inline
int FFaCmdLineEntry<int>::convertOption(const std::string& value)
{
  if (value.empty())
    return 0;
 
  char* endPtr;
  long int aval = strtol(value.c_str(),&endPtr,10);
  if (*endPtr) return 1 + (endPtr - value.c_str());
 
  myValue = (int)aval;
  iAmSetOnCmdLine = true;
  return 0;
}
 
 
template<> inline
int FFaCmdLineEntry<float>::convertOption(const std::string& value)
{
  if (value.empty())
    return 0;
 
  char* endPtr;
  float aval = strtof(value.c_str(),&endPtr);
  if (*endPtr) return 1 + (endPtr - value.c_str());
 
  myValue = aval;
  iAmSetOnCmdLine = true;
  return 0;
}
 
 
template<> inline
int FFaCmdLineEntry<double>::convertOption(const std::string& value)
{
  if (value.empty())
    return 0;
 
  char* endPtr;
  double aval = strtod(value.c_str(),&endPtr);
  if (*endPtr) return 1 + (endPtr - value.c_str());
 
  myValue = aval;
  iAmSetOnCmdLine = true;
  return 0;
}
 
 
template<> inline
int FFaCmdLineEntry<IntVec>::convertOption(const std::string& value)
{
  myValue.clear();
  if (value.empty())
    return 0;
 
  char* endPtr;
  long int aval = strtol(value.c_str(),&endPtr,10);
  while (*endPtr)
  {
    char* next = endPtr;
    if (!isdigit(next[0]) && !isspace(next[0]) &&
        next[0] != '-' && next[0] != '+')
      return 1 + (endPtr - value.c_str());
 
    myValue.push_back((int)aval);
    aval = strtol(next,&endPtr,10);
  }
 
  myValue.push_back(aval);
  iAmSetOnCmdLine = true;
  return 0;
}
 
 
template<> inline
int FFaCmdLineEntry<DoubleVec>::convertOption(const std::string& value)
{
  myValue.clear();
  if (value.empty())
    return 0;
 
  char* endPtr;
  double aval = strtod(value.c_str(),&endPtr);
  while (*endPtr)
  {
    char* next = endPtr;
    if (!isdigit(next[0]) && !isspace(next[0]) &&
        next[0] != '-' && next[0] != '+' && next[0] != '.')
      return 1 + (endPtr - value.c_str());
 
    myValue.push_back(aval);
    aval = strtod(next,&endPtr);
  }
 
  myValue.push_back(aval);
  iAmSetOnCmdLine = true;
  return 0;
}
 
 
template<class T> inline
std::string vec2string(const std::vector<T>& value)
{
  if (value.empty())
    return "";
 
  std::stringstream sval;
  sval << value.front();
  for (size_t i = 1; i < value.size(); i++)
    sval <<" "<< value[i];
 
  return sval.str();
}
 
template<> inline
std::string FFaCmdLineEntry<IntVec>::toString(const IntVec& value) const
{
  return vec2string(value);
}
 
template<> inline
std::string FFaCmdLineEntry<DoubleVec>::toString(const DoubleVec& value) const
{
  return vec2string(value);
}
 
 
template<> inline
int FFaCmdLineEntry<std::string>::convertOption(const std::string& value)
{
  if (value.empty())
    return 0;
 
  myValue = value;
  if (myValue.size() > 1)
  {
    // remove fnutts if they are first and last in the string:
    if (*myValue.begin()  == '"') myValue.erase(myValue.begin());
    if (*myValue.rbegin() == '"') myValue.erase(myValue.end()-1);
  }
  iAmSetOnCmdLine = true;
  return 0;
}
 
 
template<> inline
int FFaCmdLineEntry<bool>::convertOption(const std::string& value)
{
  if (value.empty())
    myValue = true;
  else if (value.size() != 1)
    return false;
  else if (value == "+")
    myValue = true;
  else if (value == "-")
    myValue = false;
  else
    return 1;
 
  iAmSetOnCmdLine = true;
  return 0;
}
 
 
template<class T> inline
const std::vector<T>& complDefault(const std::vector<T>& value,
                                   const std::vector<T>& defval)
{
  if (value.empty())
    return defval;
  else if (value.size() >= defval.size())
    return value;
 
  static std::vector<T> tmp;
  tmp.assign(value.begin(),value.end());
  tmp.insert(tmp.end(),defval.begin()+value.size(),defval.end());
  return tmp;
}
 
template<> inline
const DoubleVec& FFaCmdLineEntry<DoubleVec>::getValue() const
{
  return complDefault(myValue,myDefault);
}
 
template<> inline
const IntVec& FFaCmdLineEntry<IntVec>::getValue() const
{
  return complDefault(myValue,myDefault);
}
 
#endif