EnumStrings.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_COMMON_ENUM_HPP_
#define GEOSX_COMMON_ENUM_HPP_

#include "codingUtilities/StringUtilities.hpp"
#include "common/DataTypes.hpp"
#include "common/Logger.hpp"

#include <iostream>
#include <sstream>
#include <array>
#include <type_traits>
#include <algorithm>

namespace geosx
{

namespace internal
{
template< typename ... ARGS >
constexpr int countArgs( ARGS ... )
{
  return sizeof...( ARGS );
}
}

#define ENUM_STRINGS( ENUM, ... )                                     \
  static_assert( std::is_enum< ENUM >::value, "Not an enumeration" ); \
                                                                      \
  inline auto const & getEnumStrings( ENUM const )                    \
  {                                                                   \
    constexpr int N = internal::countArgs( __VA_ARGS__ );             \
    static constexpr std::array< char const *, N > ss{ __VA_ARGS__ }; \
    return ss;                                                        \
  }                                                                   \
                                                                      \
  inline std::ostream & operator<<( std::ostream & os, ENUM const e ) \
  {                                                                   \
    os << EnumStrings< ENUM >::toString( e );                         \
    return os;                                                        \
  }                                                                   \
                                                                      \
  inline std::istream & operator>>( std::istream & is, ENUM & e )     \
  {                                                                   \
    string s; is >> s;                                                \
    e = EnumStrings< ENUM >::fromString( s );                         \
    return is;                                                        \
  }

template< typename ENUM >
struct EnumStrings
{
  using enum_type = ENUM;

  using base_type = std::underlying_type_t< ENUM >;

  static auto const & get()
  {
    return getEnumStrings( enum_type{} ); // invoke ADL
  }

  static string concat( string const & delim = " " )
  {
    auto const & strings = get();
    return ::geosx::stringutilities::strjoin( begin( strings ), end( strings ), delim );
  }

  static string toString( enum_type const & e )
  {
    auto const & strings = get();
    base_type const index = static_cast< base_type >( e );
    GEOSX_ERROR_IF_GE_MSG( index, LvArray::integerConversion< base_type >( strings.size() ),
                           "Unrecognized value of " << TypeName< ENUM >::brief() << ": " << index << ".\n" <<
                           "Valid range is 0.." << strings.size() - 1 );
    return strings[ index ];
  }

  static enum_type fromString( string const & s )
  {
    auto const & strings = get();
    auto const it = std::find( begin( strings ), end( strings ), s );
    GEOSX_ERROR_IF( it == strings.end(),
                    "'" << s << "' is not a recognized value of " << TypeName< enum_type >::brief() << ".\n" <<
                    "Valid options are: \n  " << concat( "\n  " ) );
    enum_type const e = static_cast< enum_type >( LvArray::integerConversion< base_type >( std::distance( begin( strings ), it ) ) );
    return e;
  }
};

namespace internal
{
IS_VALID_EXPRESSION( HasEnumStrings, ENUM, getEnumStrings( std::declval< ENUM >() ) );
}

template< typename ENUM >
struct TypeRegex< ENUM, std::enable_if_t< internal::HasEnumStrings< ENUM > > >
{
  static std::string get()
  {
    return EnumStrings< ENUM >::concat( "|" );
  }
};

} // namespace geosx

#endif //GEOSX_COMMON_ENUM_HPP_