Enum.h

Go to the documentation of this file.

// -*- C++ -*-
/* GG is a GUI for SDL and OpenGL.
   Copyright (C) 2003 T. Zachary Laine

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1
   of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
    
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA

   If you do not wish to comply with the terms of the LGPL please
   contact the author as other terms are available for a fee.
    
   Zach Laine
   whatwasthataddress@hotmail.com */
   
#ifndef _GG_Enum_h_
#define _GG_Enum_h_

#include <map>
#include <string>


namespace GG {

struct EnumMapBase
{
    enum {BAD_VALUE = -5000000};

    virtual ~EnumMapBase() {} 

    virtual const std::string& FromEnum(int i) const = 0;

    virtual int FromString (const std::string& str) const = 0;
};

template <class E> struct EnumMap : EnumMapBase
{
    virtual ~EnumMap() {} 
    virtual const std::string& FromEnum(int) const
    { static std::string empty; return empty; }
    virtual int FromString (const std::string&) const {return 0;}
};

template <class E> EnumMap<E> GetEnumMap()
{
    static EnumMap<E> enum_map;
    return enum_map;
}

#define GG_ENUM_MAP_BEGIN( name )                                       \
template <> struct EnumMap< name > : EnumMapBase                        \
{                                                                       \
    typedef name EnumType;                                              \
    typedef std::map<EnumType, std::string> MapType;                    \
    EnumMap ()                                                          \
    {

#define GG_ENUM_MAP_INSERT( value ) m_map[ value ] = #value ;

#define GG_ENUM_MAP_END                                                 \
    }                                                                   \
    virtual const std::string& FromEnum(int i) const                    \
    {                                                                   \
        static const std::string ERROR_STR;                             \
        std::map<EnumType, std::string>::const_iterator it =            \
            m_map.find(EnumType(i));                                    \
        return it == m_map.end() ? ERROR_STR : it->second;              \
    }                                                                   \
    int FromString (const std::string &str) const                       \
    {                                                                   \
        for (MapType::const_iterator it = m_map.begin();                \
             it != m_map.end();                                         \
             ++it) {                                                    \
            if (it->second == str)                                      \
                return it->first;                                       \
        }                                                               \
        return BAD_VALUE;                                               \
    }                                                                   \
    MapType m_map;                                                      \
};

#define GG_ENUM_STREAM_IN( name )                                       \
    inline std::istream& operator>>(std::istream& is, name& v)          \
    {                                                                   \
        std::string str;                                                \
        is >> str;                                                      \
        v = name (GG::GetEnumMap< name >().FromString(str));            \
        return is;                                                      \
    }

#define GG_ENUM_STREAM_OUT( name )                                      \
    inline std::ostream& operator<<(std::ostream& os, name v)           \
    {                                                                   \
        os << GG::GetEnumMap< name >().FromEnum(v);                     \
        return os;                                                      \
    }

} // namespace GG

#endif // _GG_Enum_h_

---