StringUtils.hpp

#pragma once
#ifndef __H__OCULAR_CORE_UTILS_STRING_OPERATIONS__H__
#define __H__OCULAR_CORE_UTILS_STRING_OPERATIONS__H__

#include "VoidCast.hpp"

#include <string>
#include <cstdint>
#include <sstream>
#include <iomanip>
#include <functional>
#include <unordered_map>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Utils
    {
        class String
        {
        public:

            String();
            ~String();

            //------------------------------------------------------------------------------
            // General String Operations
            //------------------------------------------------------------------------------

            static std::string ToLower(std::string const& str);

            static std::string ToUpper(std::string const& str);

            static bool IsEqual(std::string const& strA, std::string const& strB, bool ignoreCase = false);

            static bool Contains(std::string const& source, std::string const& find, bool ignoreCase = false);

            static std::string FormatWindowsError(unsigned long error);

            static std::string FormatBytes(uint64_t bytes);

            static void Split(std::string const& str, char delim, std::vector<std::string>& tokens);

            template<typename T>
            static typename std::enable_if<std::is_arithmetic<T>::value, std::string>::type FormatHex(T const x)
            {
                std::stringstream sstream;
                sstream << "0x" << std::setfill('0') << std::setw(sizeof(T) * static_cast<T>(2)) << std::hex << x;

                return sstream.str();
            }

            //------------------------------------------------------------------------------
            // To/From Methods and Helpers
            //------------------------------------------------------------------------------

            // The following methods can not be static like the rest. If we make the maps static, then
            // their is a very strong likelihood that some other static initializer will call these methods,
            // particularly the registers, before the String static initializers can act. This leads to
            // a crash when performing a search in the uninitialized map and why this class was added
            // to the main engine class as OcularString.

            template<typename T>
            typename std::enable_if<!std::is_pointer<T>::value, std::string>::type toString(T const& data, bool isPointer = false) const
            {
                std::string result;

                const std::string tStr = TypeName<T>::name;
                auto find = m_ToFunctions.find(tStr);

                if(find != m_ToFunctions.end())
                {
                    result = find->second(void_cast<T>(data), isPointer);
                }

                return result;
            }

            template<typename T>
            typename std::enable_if<!std::is_pointer<T>::value, bool>::type toString(T const& data, std::string& str, bool isPointer = false) const
            {
                bool result = false;

                const std::string tStr = TypeName<T>::name;
                auto find = m_ToFunctions.find(tStr);

                if(find != m_ToFunctions.end())
                {
                    str = find->second(void_cast<T>(data), isPointer);
                    result = true;
                }

                return result;
            }

            std::string toString(std::string const& type, void* data, bool isPointer = false) const
            {
                std::string result;

                if(data)
                {
                    auto find = m_ToFunctions.find(type);

                    if(find != m_ToFunctions.end())
                    {
                        result = find->second(data, isPointer);
                    }
                }

                return result;
            }

            bool toString(std::string const& type, void* data, std::string& str, bool isPointer = false) const
            {
                bool result = false;

                if(data)
                {
                    auto find = m_ToFunctions.find(type);

                    if(find != m_ToFunctions.end())
                    {
                        str = find->second(data, isPointer);
                        result = true;
                    }
                }

                return result;
            }

            template<typename T>
            typename std::enable_if<!std::is_pointer<T>::value, T>::type fromString(std::string const& value) const
            {
                T result;

                const std::string tStr = TypeName<T>::name;
                auto find = m_FromFunctions.find(tStr);

                if(find != m_FromFunctions.end())
                {
                    find->second(value, void_cast<T*>(&result));
                }

                return result;
            }

            template<typename T>
            typename std::enable_if<!std::is_pointer<T>::value, bool>::type fromString(std::string const& value, T& object) const
            {
                bool result = false;
                auto find = m_FromFunctions.find(value);

                if(find != m_FromFunctions.end())
                {
                    find->second(value, object);
                    result = true;
                }

                return result;
            }

            bool fromString(std::string const& type, std::string const& value, void* object)
            {
                bool result = false;

                if(object)
                {
                    auto find = m_FromFunctions.find(type);

                    if(find != m_FromFunctions.end())
                    {
                        find->second(value, object);
                        result = true;
                    }
                }

                return result;
            }

            template<typename T>
            typename std::enable_if<!std::is_pointer<T>::value, void>::type registerToString(std::function<std::string(void*, bool)> func)
            {
                const std::string tStr = TypeName<T>::name;
                auto find = m_ToFunctions.find(tStr);

                if(find == m_ToFunctions.end())
                {
                    m_ToFunctions.insert({tStr, func});
                }
            }

            template<typename T>
            typename std::enable_if<!std::is_pointer<T>::value, void>::type registerFromString(std::function<void(std::string const&, void*)> func)
            {
                const std::string tStr = TypeName<T>::name;
                auto find = m_FromFunctions.find(tStr);

                if(find == m_FromFunctions.end())
                {
                    m_FromFunctions.insert({tStr, func});
                }
            }

        protected:

        private:

            std::unordered_map<std::string, std::function<std::string(void*, bool)>> m_ToFunctions;
            std::unordered_map<std::string, std::function<void(std::string const&, void*)>> m_FromFunctions;
        };
    }
}
//------------------------------------------------------------------------------------------

#endif