KarmaTypes.h

#pragma once
 
#include <vector>
#include <cstdint>
#include <map>
#include <utility>
#include <algorithm>
 
namespace EEndPlayReason
{
    enum Type : int
    {
        Destroyed,
        LevelTransition,
        EndPlayInEditor,
        RemovedFromWorld,
        Quit,
    };
}
 
namespace EWorldType
{
    enum Type
    {
        None,
 
        Game,
 
        Editor,
 
        PIE,
 
        EditorPreview,
 
        GamePreview,
 
        GameRPC,
 
        /* An editor world that was loaded but not currently being edited in the level editor */
        Inactive
    };
}
 
template <typename KeyType, typename ValueType>
class KarmaMap
{
public:
    typedef std::map<KeyType, ValueType> AMap;
    typedef typename AMap::iterator AnIterator;
 
    KarmaMap()
    {
 
    }
 
    ValueType& FindOrAdd(const KeyType& Key)
    {
        ValueType aValue;
        std::pair<AnIterator, bool> const& result = m_KeyValuePair.insert(typename AMap::value_type(Key, aValue));
 
        // a simple return.first->second could work. doing this for better understandibility
        if(result.second)
        {
            // Value was inserted, meaning wasn't there earlier
            return result.first->second;
        }
        else
        {
            // Nothing inserted, meaning value with key already exists
            return result.first->second;
        }
    }
 
    ValueType* Find(const KeyType& Key)
    {
        AnIterator result = m_KeyValuePair.find(Key);
 
        if(result != m_KeyValuePair.end())
        {
            return &result->second;
        }
 
        return nullptr;
    }
protected:
    AMap m_KeyValuePair;
};
 
template<typename BuildingBlock>
class KarmaVector
{
public:
    KarmaVector()
    {
    }
 
    ~KarmaVector()
    {
    }
 
    uint32_t Remove(BuildingBlock aBlock)
    {
        uint32_t occurences = 0;
        typename std::vector<BuildingBlock>::iterator iterator = m_Elements.begin();
 
        while (iterator != m_Elements.end())
        {
            if (*iterator == aBlock)
            {
                iterator = m_Elements.erase(iterator);
                occurences++;
            }
            else
            {
                ++iterator;
            }
        }
 
        return occurences;
    }
 
    void Add(BuildingBlock aBlock)
    {
        m_Elements.push_back(aBlock);
    }
 
    FORCEINLINE int32_t AddUnique(const BuildingBlock& Item)
    {
        int32_t index = Find(Item);
 
        if(index == -1)
        {
            Add(Item);
            return Num() - 1;
        }
        else
        {
            return index;
        }
    }
 
    int32_t Find(const BuildingBlock& Item) const
    {
        int32_t returnIndex = 0;
 
        typename std::vector<BuildingBlock>::const_iterator iter = m_Elements.begin();
 
        for (; iter != m_Elements.end(); iter++)
        {
            if (m_Elements[returnIndex] == Item)
            {
                break;
            }
            returnIndex++;
        }
 
        if (iter != m_Elements.end())
        {
            return returnIndex;
        }
 
        // Make an enum with name INDEX_NONE and value -1
        return -1;
    }
 
    bool Contains(BuildingBlock aBlock) const
    {
        typename std::vector<BuildingBlock>::const_iterator iterator = m_Elements.begin();
 
        while (iterator != m_Elements.end())
        {
            if (*iterator == aBlock)
            {
                return true;
            }
            else
            {
                ++iterator;
            }
        }
 
        return false;
    }
 
    uint32_t Num() const
    {
        return (uint32_t) m_Elements.size();
    }
 
    void Reset()
    {
        // Maybe make smartpointer instead of manually deleting
        typename std::vector<BuildingBlock>::iterator iter = m_Elements.begin();
 
        // solution got from https://www.reddit.com/r/cpp_questions/comments/panivh/constexpr_if_statement_to_check_if_template/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button
        if constexpr(std::is_pointer_v<BuildingBlock>)
        {
            for (iter = m_Elements.begin(); iter != m_Elements.end(); iter++)
            {
                if (*iter != nullptr)
                {
                    KR_CORE_INFO("Deleting UObjects");
                    delete *iter;
                    *iter = nullptr;
                }
            }
        }
 
        m_Elements.clear();
    }
 
    void SmartReset()
    {
        m_Elements.clear();
    }
 
    void SetVectorElementByIndex(int32_t Index, BuildingBlock Value)
    {
        m_Elements[Index] = Value;
    }
 
    inline const std::vector<BuildingBlock>& GetElements() const { return m_Elements; }
    inline std::vector<BuildingBlock>& ModifyElements() { return m_Elements; }
 
    typename std::vector<BuildingBlock>::iterator begin()
    {
        return m_Elements.begin();
    }
 
    typename std::vector<BuildingBlock>::iterator end()
    {
        return m_Elements.end();
    }
 
    FORCEINLINE BuildingBlock& IndexToObject(int32_t Index)
    {
        KR_CORE_ASSERT(Index >= 0, "");
        if(Index < m_Elements.size())
        {
            return m_Elements.at(Index);
        }
 
        KR_CORE_ASSERT(false, "Shouldn't happen");
 
        static BuildingBlock aBlock;
        return aBlock;
    }
 
    FORCEINLINE bool IsValidIndex(int32_t Index) const
    {
        return Index >= 0 && Index < m_Elements.size();
    }
 
 
protected:
    std::vector<BuildingBlock> m_Elements;
};
 
// Traveling from server to server.
enum ETravelType
{
    TRAVEL_Absolute,
 
    TRAVEL_Partial,
 
    TRAVEL_Relative,
 
    TRAVEL_MAX,
};
 
struct KARMA_API FUrlConfig
{
    std::string m_DefaultProtocol;
    std::string m_DefaultName;
    std::string m_DefaultHost;
    std::string m_DefaultPortal;
    std::string m_DefaultSaveExt;
    int32_t m_DefaultPort;
 
    void Init();
 
    void Reset();
};
 
//URL structure.
struct KARMA_API FURL
{
    // Protocol, i.e. "karma" or "http".
    std::string m_Protocol;
 
    // Optional hostname, i.e. "204.157.115.40" or "unreal.epicgames.com", blank if local.
    std::string m_Host;
 
    // Optional host port.
    int32_t m_Port;
 
    int32_t m_Valid;
 
    // Map name, i.e. "SkyCity", default is "Entry".
    std::string m_Map;
 
    // Optional place to download Map if client does not possess it
    std::string m_RedirectURL;
 
    // Options.
    //TArray<FString> Op;
 
    // Portal to enter through, default is "".
    std::string m_Portal;
 
    // Statics.
    static FUrlConfig UrlConfig;
    static bool m_bDefaultsInitialized;
 
    //explicit FURL(ENoInit) { }
 
    FURL(const std::string& Filename = "");
 
    //FURL(FURL* Base, const TCHAR* TextURL, ETravelType Type);
 
    //static void StaticInit();
    //static void StaticExit();
 
    //static void FilterURLString(const std::string& Str);
 
    //bool IsInternal() const;
 
    //bool IsLocalInternal() const;
 
    //bool HasOption(const TCHAR* Test) const;
 
    //const TCHAR* GetOption(const TCHAR* Match, const TCHAR* Default) const;
 
    //void LoadURLConfig(const TCHAR* Section, const std::string& Filename = "GGameIni");
 
    //void SaveURLConfig(const TCHAR* Section, const TCHAR* Item, const std::string& Filename = "GGameIni") const;
 
    //void AddOption(const TCHAR* Str);
 
    //void RemoveOption(const TCHAR* Key, const TCHAR* Section = nullptr, const std::string& Filename = "GGameIni");
 
    //std::string ToString(bool FullyQualified = 0) const;
 
    //std::string GetHostPortString() const;
 
    //ENGINE_API friend FArchive& operator<<(FArchive& Ar, FURL& U);
 
    //bool operator==(const FURL& Other) const;
};