FFaEnum.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_ENUM_H
#define FFA_ENUM_H
 
#include <vector>
#include <utility>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <iostream>
 
 
template<class EnumType, class ETMapping> class FFaEnum
{
public:
  FFaEnum(EnumType val = EnumType(0)) : myValue(val) {}
  FFaEnum(const char* val) { *this = val; }
 
  FFaEnum<EnumType,ETMapping>& operator=(const FFaEnum<EnumType,ETMapping>& val)
  {
    if (this != &val)
      this->myValue = val.myValue;
    return *this;
  }
 
  FFaEnum<EnumType,ETMapping>& operator=(const EnumType& val)
  {
    this->myValue = val;
    return *this;
  }
 
  FFaEnum<EnumType,ETMapping>& operator=(const int& val)
  {
    this->myValue = EnumType(val);
    return *this;
  }
 
  FFaEnum<EnumType,ETMapping>& operator=(const char* text)
  {
    if (!text || strlen(text) < 1)
      return *this; // Empty string, don't touch the value
 
    // Ignore leading and trailing whitespace, if any
    size_t istart = 0, iend = strlen(text)-1;
    while (isspace(text[istart]))
      if (++istart > iend)
      {
        // Blank string, treat as zero
        this->myValue = EnumType(0);
        return *this;
      }
 
    while (iend > istart && isspace(text[iend]))
      --iend;
 
    for (const std::pair<EnumType,const char*>& ep : ETMapping::map())
      if (strncmp(ep.second,text+istart,iend-istart+1) == 0)
      {
        // Found a matching string value
        this->myValue = ep.first;
        return *this;
      }
 
    // No match, check if the string is some integer value
    for (size_t i = istart; i <= iend; i++)
      if (!isdigit(text[i]))
        return *this;
 
    // Try to convert the integer value to the enum value
    this->myValue = EnumType(atoi(text+istart));
    return *this;
  }
 
  operator EnumType() const { return this->myValue; }
 
  const char* getText() const
  {
    for (const std::pair<EnumType,const char*>& ep : ETMapping::map())
      if (ep.first == this->myValue)
        return ep.second;
 
    // Fall-back in case of an enum value without matching string value
    static char text[16];
    snprintf(text,16,"%d",this->myValue);
    return text;
  }
 
  bool operator==(const FFaEnum<EnumType,ETMapping>& e) const { return this->myValue == e.myValue; }
  bool operator==(const EnumType&                    e) const { return this->myValue == e; }
 
  bool operator!=(const FFaEnum<EnumType,ETMapping>& e) const { return this->myValue != e.myValue; }
  bool operator!=(const EnumType&                    e) const { return this->myValue != e; }
 
private:
  EnumType myValue; 
};
 
 
template<class EnumType, class ETMapping>
std::ostream& operator<<(std::ostream& s, const FFaEnum<EnumType,ETMapping>& e)
{
  return s << e.getText();
}
 
template<class EnumType, class ETMapping>
std::istream& operator>>(std::istream& s, FFaEnum<EnumType,ETMapping>& e)
{
  char enumText[128];
  size_t iend = 0;
  while (iend < 127 && s.get(enumText[iend]))
    if (!isspace(enumText[iend]))
      ++iend;
    else if (iend > 0)
      break;
 
  if (iend == 0)
    return s; // Empty string, don't touch anything
  else if (enumText[0] == '"' && enumText[iend-1])
  {
    if (iend < 3) return s; // Empty string, don't touch anything
    // Remove the embedding '"'-characters
    enumText[0] = ' ';
    --iend;
  }
 
  enumText[iend] = '\0';
  e = enumText;
  s.clear();
  return s;
}
 
 
#define FFaEnumMapping(EnumType)                    \
  class EnumType##Mapping;                      \
  typedef FFaEnum<EnumType,EnumType##Mapping> EnumType##Enum;       \
  class EnumType##Mapping                       \
  {                                 \
    typedef std::pair<EnumType,const char*> EnumType##Pair;     \
  public:                               \
    static const std::vector<EnumType##Pair> map()          \
    {                                   \
      std::vector<EnumType##Pair> enumMap;              \
      if (enumMap.empty())
 
#define FFaEnumEntry(EnumValue,EnumText)            \
  enumMap.push_back(std::make_pair(EnumValue,EnumText));
 
#define FFaEnumEntryEnd             \
  } return enumMap; }
 
#endif