Read in string from file, and convert them into enum?

[northfly]

I defined

enum boundaryType_t {inside, inlet, outlet, wall, periodic};

now I have file written like this:

inside outlet

I want my program read the file and when encounter any enum type, instead of treating it as a string, I want the program store it in memory as a enum value.

How can I do that? Thanks!

string s;
ifs>>s;
s // how to convert it to enum??? 

[northfly]

maybe, I should ask question about how to overload istream operator >> for an enum type?

[Duthomhas]

For a straight-up enum, just read the string and compare it to an array of strings. The index of the match is the enum value, and a simple cast will get the proper value.

For an enum with arbitrary values, you also need to provide a lookup table to convert between the match index and the enum value.

For typed enums, you can do it directly in an overloaded operator >>, but for the old enums I would wrap it in an input manipulator.

Hope this helps.

[northfly]

Thanks, Duoas! I want to go with the overloaded operator >> , how can I do that?

[Duthomhas]

Complete example for you.

#include <iostream>
#include <string>

//----------------------------------------------------------------------------
// enum class boundaryType_t
//----------------------------------------------------------------------------

#define FOREACH_OP(F) \
  F(inside) \
  F(inlet)  \
  F(outlet) \
  F(wall)   \
  F(periodic)

enum class boundaryType_t
  {
  #define F(x) x,
  FOREACH_OP(F)
  #undef F
  };

namespace
  {
  inline const char* boundaryType_t_names( unsigned n )
    {
    const char* boundary_type_names[] = 
      {
      #define F(x) #x ,
      FOREACH_OP(F)
      #undef F
      NULL
      };
    return boundary_type_names[ n ];
    }  

  inline boundaryType_t boundaryType_t_values( unsigned n )
    {
    boundaryType_t boundary_type_values[] =
      {
      #define F(x) boundaryType_t::x,
      FOREACH_OP(F)
      #undef F
      };
    return boundary_type_values[ n ];
    }
  } // namespace 
  
#undef FOREACH_OP

std::istream& operator >> ( std::istream& ins, boundaryType_t& bt )
  {
  if (!ins) return ins;
  std::string name;
  ins >> name;
  if (ins)
    {
    for (unsigned n = 0; boundaryType_t_names( n ); n++)
      {
      if (name == boundaryType_t_names( n ))
        {
        bt = boundaryType_t_values( n );
        return ins;
        }
      }
    }
  ins.setstate( std::ios::failbit );
  return ins;
  }

std::ostream& operator << ( std::ostream& outs, const boundaryType_t& bt )
  {
  for (unsigned n = 0; boundaryType_t_names( n ); n++)
    {
    if (bt == boundaryType_t_values( n ))
      {
      return outs << boundaryType_t_names( n );
      }
    }
  outs.setstate( std::ios::failbit );
  return outs;
  }
  
  
//----------------------------------------------------------------------------
// Main program
//----------------------------------------------------------------------------

#include <limits>
  
int main()
  {
  using namespace std;
  
  cout << "Enter one of:\n";
  cout << boundaryType_t::inside   << "\n";
  cout << boundaryType_t::inlet    << "\n";
  cout << boundaryType_t::outlet   << "\n";
  cout << boundaryType_t::wall     << "\n";
  cout << boundaryType_t::periodic << "\n";
  cout << "> ";
  
  boundaryType_t bt;
  while (!(cin >> bt))
    {
    cin.clear();
    cin.ignore( numeric_limits <streamsize> ::max(), '\n' );
    cout << "Invalid! Try again\n> ";
    }
  cin.ignore( numeric_limits <streamsize> ::max(), '\n' );
  
  cout << "Good job! You entered " << bt << ".\n";
  return 0;
  }

Hope this helps.

[northfly]

Oh, My god, Thanks a lot, Duoas! I think I need sometime to digest it! Thanks!