source: dev/branches/egtra/ab5.0/abdev/BasicCompiler_Common/include/Enum.h

#pragma once

class EnumMember
{
    std::string name;
    std::string value;
    int sourceIndex;

public:
    EnumMember( const std::string &name, const std::string &value, int sourceIndex )
        : name( name )
        , value( value )
        , sourceIndex( sourceIndex )
    {
    }

    EnumMember(EnumMember&& y)
        : name(std::move(y.name))
        , value(std::move(y.value))
        , sourceIndex(std::move(y.sourceIndex))
    {
    }

    EnumMember(EnumMember const& y)
        : name(y.name)
        , value(y.value)
        , sourceIndex(y.sourceIndex)
    {
    }

    EnumMember& operator =(EnumMember&& y)
    {
        name = std::move(y.name);
        value = std::move(y.value);
        sourceIndex = std::move(y.sourceIndex);
        return *this;
    }

    EnumMember& operator =(EnumMember const& y)
    {
        return *this = std::move(EnumMember(y));
    }

    const std::string &GetName() const
    {
        return name;
    }
    const std::string &GetValueStr() const
    {
        return value;
    }
    int GetSourceIndex() const
    {
        return sourceIndex;
    }
};

class EnumInfo
    : public Symbol
{

    BOOL bConst;

    std::vector<EnumMember> members;
public:

    EnumInfo( const NamespaceScopes &namespaceScopes, const std::string &name )
        : Symbol( namespaceScopes, name )
    {
    }

    EnumInfo(EnumInfo&& y)
        : Symbol(std::move(y))
        , bConst(std::move(y.bConst))
        , members(std::move(y.members))
    {
    }

    EnumInfo(EnumInfo const& y)
        : Symbol(y)
        , bConst(y.bConst)
        , members(y.members)
    {
    }

    EnumInfo& operator =(EnumInfo&& y)
    {
        Symbol::operator =(std::move(y));
        bConst = std::move(y.bConst);
        members = std::move(y.members);
        return *this;
    }

    EnumInfo& operator =(EnumInfo const& y)
    {
        return *this = std::move(EnumInfo(y));
    }

    const std::vector<EnumMember> &GetMembers() const
    {
        return members;
    }

    const EnumMember &GetEnumMember( const std::string &memberName ) const
    {
        foreach( const EnumMember &member, members )
        {
            if( member.GetName() == memberName )
            {
                return member;
            }
        }
        throw;
    }

    std::vector<EnumMember> &GetEnumMembers()
    {
        return members;
    }
};

class EnumInfoCollection
    : public std::vector<EnumInfo>
{
public:
    const EnumInfo *Find( const Symbol &symbol ) const
    {
        const EnumInfoCollection &thisEnumInfoCollection = *this;
        foreach( const EnumInfo &enumInfo, thisEnumInfoCollection )
        {
            if( enumInfo.IsEqualSymbol( symbol ) )
            {
                return &enumInfo;
            }
        }
        return NULL;
    };

    EnumInfoCollection() {}

private:
    EnumInfoCollection(EnumInfoCollection const&);
    EnumInfoCollection& operator =(EnumInfoCollection const&);
};