EnumerationString.h

Go to the documentation of this file.

/*
* True Reality Open Source Game and Simulation Engine
* Copyright © 2021 Acid Rain Studios LLC
*
* The Base of this class has been adopted from the Delta3D engine
*
* 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 3.0 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
*
* Class Inspired by the Delta3D Engine
* http://delta3dengine.org/
*
* @author Matthew W. Campbell
* @author David Guthrie
* @author Maxim Serebrennik
*/
#pragma once

#include "Export.h"

#include <trUtil/WarningUtils.h>

#include <ostream>
#include <string>
#include <vector>

TR_DISABLE_WARNING_START_MSVC(4276)


namespace trUtil
{
    class TR_UTIL_EXPORT EnumerationString
    {
    public:

        const std::string& GetName() const
        {
            return mName;
        }

        bool operator==(const EnumerationString& rhs) const
        {
            return this == &rhs;
        }

        bool operator!=(const EnumerationString& rhs) const
        {
            return this != &rhs;
        }

        bool operator==(const std::string& rhs) const;

        bool operator!=(const std::string& rhs) const;

        bool operator<(const std::string& rhs) const;

        bool operator>(const std::string& rhs) const;

        bool operator<(const EnumerationString& rhs) const
        {
            return this < &rhs;
        }
    protected:

        virtual int Compare(const std::string& nameString) const;

        virtual ~EnumerationString();

        EnumerationString(const std::string& name);
    private:

        EnumerationString& operator=(const EnumerationString&);

        std::string mName;

        EnumerationString(const EnumerationString&);
    };

    TR_UTIL_EXPORT std::ostream& operator<<(std::ostream& os, const EnumerationString& e);


#define DECLARE_ENUM(EnumType)                                 \
public:                                                        \
    using EnumerateListType = std::vector<EnumType*>;           \
    \
    static const EnumerateListType& EnumerateType()             \
    {                                                           \
    return EnumType::mInstances;                             \
    }                                                           \
    \
    static const std::vector<trUtil::EnumerationString*>& Enumerate() \
    {                                                           \
    return EnumType::mGenericInstances;                      \
    }                                                           \
    \
    static EnumType* GetValueForName(const std::string& name);  \
    \
private:                                                       \
    static EnumerateListType mInstances;                        \
    static std::vector<trUtil::EnumerationString*> mGenericInstances; \
    static void AddInstance(EnumType* instance);                \
public:

#define IMPLEMENT_ENUM(EnumType)                               \
    EnumType::EnumerateListType EnumType::mInstances;           \
    std::vector<trUtil::EnumerationString*> EnumType::mGenericInstances; \
    void EnumType::AddInstance(EnumType* instance)                 \
    {                                                           \
    EnumType::mInstances.push_back(instance);                \
    EnumType::mGenericInstances.push_back(instance);         \
    }                                                           \
    EnumType* EnumType::GetValueForName(const std::string& name)   \
    {                                                           \
    for (unsigned i = 0; i < mInstances.size(); ++i)         \
    {                                                        \
    if ((*mInstances[i]) == name)                 \
    {                                                     \
    return mInstances[i];                              \
    }                                                     \
    }                                                        \
    return nullptr;                                             \
    }


    template <typename T>
    class EnumerationPointer
    {
    public:
        using element_type = T;

        EnumerationPointer() : mEnum(nullptr)
        {
        }

        EnumerationPointer(T* ptr) : mEnum(ptr)
        {
        }

        EnumerationPointer(const EnumerationPointer& rp) : mEnum(rp.mEnum)
        {
        }

        template<class Other> EnumerationPointer(const EnumerationPointer<Other>& rp) : mEnum(rp.mEnum)
        {
        }

        ~EnumerationPointer()
        {
            mEnum = nullptr;
        }

        operator T*() const
        {
            return mEnum;
        }

        operator T&() const
        {
            return *mEnum;
        }

        EnumerationPointer& operator=(const EnumerationPointer& rp)
        {
            mEnum = rp.mEnum;
            return *this;
        }

        template<class Other> EnumerationPointer& operator=(const EnumerationPointer<Other>& rp)
        {
            mEnum = rp.mEnum;
            return *this;
        }

        inline EnumerationPointer& operator=(T* ptr)
        {
            if (mEnum == ptr) return *this;
            mEnum = ptr;
            return *this;
        }

        inline EnumerationPointer& operator=(T& enumRef)
        {
            if (mEnum == &enumRef) return *this;
            mEnum = &enumRef;
            return *this;
        }

        bool operator==(const EnumerationPointer& rp) const
        {
            return (mEnum == rp.mEnum);
        }

        bool operator==(const T* ptr) const
        {
            return (mEnum == ptr);
        }

        friend bool operator==(const T* ptr, const EnumerationPointer& rp)
        {
            return (ptr == rp.mEnum);
        }

        bool operator!=(const EnumerationPointer& rp) const
        {
            return (mEnum != rp.mEnum);
        }

        bool operator!=(const T* ptr) const
        {
            return (mEnum != ptr);
        }

        friend bool operator!=(const T* ptr, const EnumerationPointer& rp)
        {
            return (ptr != rp.mEnum);
        }

        bool operator<(const EnumerationPointer& rp) const
        {
            return (mEnum < rp.mEnum);
        }

        bool operator>(const EnumerationPointer& rp) const
        {
            return (mEnum > rp.mEnum);
        }

        T& operator*() const
        {
            return *mEnum;
        }

        T* operator->() const
        {
            return mEnum;
        }

        T* get() const
        {
            return mEnum;
        }

        bool operator!() const
        {
            return mEnum == nullptr;
        } // not required

        bool valid() const
        {
            return mEnum != nullptr;
        }

        void swap(EnumerationPointer& rp)
        {
            T* tmp = mEnum;
            mEnum = rp.mEnum;
            rp.mEnum = tmp;
        }
    private:
        T* mEnum;
    };
}
TR_DISABLE_WARNING_END