utils.h

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2019 Ruhr University Bochum, Chair for Embedded Security. All Rights reserved.
// Copyright (c) 2019 Marc Fyrbiak, Sebastian Wallat, Max Hoffmann ("ORIGINAL AUTHORS"). All rights reserved.
// Copyright (c) 2021 Max Planck Institute for Security and Privacy. All Rights reserved.
// Copyright (c) 2021 Jörn Langheinrich, Julian Speith, Nils Albartus, René Walendy, Simon Klix ("ORIGINAL AUTHORS"). All Rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#pragma once
 
#include "hal_core/defines.h"
#include "hal_core/utilities/result.h"
 
#include <algorithm>
#include <functional>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace hal
{
    namespace utils
    {
        template<typename T>
        CORE_API inline bool unordered_vector_erase(std::vector<T>& vec, T element)
        {
            auto it = std::find(vec.begin(), vec.end(), element);
            if (it == vec.end())
            {
                return false;
            }
            *it = vec.back();
            vec.pop_back();
            return true;
        }
 
        template<typename T>
        CORE_API inline void indexed_vector_push_back(std::vector<T>& vec, std::unordered_map<T, u32>& positions, T element)
        {
            positions[element] = static_cast<u32>(vec.size());
            vec.push_back(element);
        }
 
        template<typename T>
        CORE_API inline bool indexed_vector_erase(std::vector<T>& vec, std::unordered_map<T, u32>& positions, T element)
        {
            const auto it = positions.find(element);
            if (it == positions.end())
            {
                return false;
            }
            const u32 index = it->second;
            positions.erase(it);
            T last = vec.back();
            vec.pop_back();
            if (last != element)
            {
                vec[index]      = last;
                positions[last] = index;
            }
            return true;
        }
 
        template<typename T>
        bool vectors_have_same_content(std::vector<T> vec_1, std::vector<T> vec_2)
        {
            if (vec_1.size() != vec_2.size())
            {
                return false;
            }
 
            std::sort(vec_1.begin(), vec_1.end());
            std::sort(vec_2.begin(), vec_2.end());
 
            return vec_1 == vec_2;
        }
 
        CORE_API inline u64 get_bit(const u64 value, const u64 index)
        {
            return (value >> index) & 1;
        }
 
        CORE_API inline u64 set_bit(const u64 value, const u64 index)
        {
            return value | ((u64)1 << index);
        }
 
        CORE_API inline u64 clear_bit(const u64 value, const u64 index)
        {
            return value & ~((u64)1 << index);
        }
 
        CORE_API inline u64 toggle_bit(const u64 value, const u64 index)
        {
            return value ^ ((u64)1 << index);
        }
 
        template<typename T>
        CORE_API bool ends_with(const T& s, const T& end)
        {
            if (s.length() >= end.length())
            {
                return (0 == s.compare(s.length() - end.length(), end.length(), end));
            }
            else
            {
                return false;
            }
        }
 
        template<typename T>
        CORE_API bool starts_with(const T& s, const T& start)
        {
            if (s.length() >= start.length())
            {
                return (0 == s.compare(0, start.length(), start));
            }
            else
            {
                return false;
            }
        }
 
        template<typename T>
        CORE_API bool is_digits(const T& s)
        {
            return std::all_of(s.begin(), s.end(), ::isdigit);
        }
 
        template<typename T>
        CORE_API bool is_integer(const T& s)
        {
            if (s.empty() || ((!isdigit(s[0])) && (s[0] != '-') && (s[0] != '+')))
            {
                return false;
            }
 
            char* p;
            strtol(s.c_str(), &p, 10);
 
            return (*p == 0);
        }
 
        template<typename T>
        CORE_API bool is_floating_point(const T& s)
        {
            std::stringstream ss(s.c_str());
            float f;
            ss >> f;
            return (ss.eof() && !ss.fail());
        }
 
        template<typename T>
        CORE_API std::vector<T> split(const T& s, const char delim, bool obey_brackets = false)
        {
            std::vector<T> result;
            T item = "";
 
            if (obey_brackets)
            {
                int bracket_level = 0;
 
                for (size_t i = 0; i < s.length(); ++i)
                {
                    char c = s.at(i);
                    switch (c)
                    {
                        case '(':
                        case '{':
                        case '[':
                            ++bracket_level;
                            break;
                        case ')':
                        case '}':
                        case ']':
                            --bracket_level;
                            break;
                        default:
                            break;
                    }
                    if (bracket_level < 0)
                    {
                        bracket_level = 0;
                    }
                    if (c == delim)
                    {
                        // No constant expression, therefore not usable in switch case
                        if (bracket_level == 0)
                        {
                            result.push_back(item);
                            item = "";
                        }
                        else
                        {
                            item.push_back(c);
                        }
                    }
                    else
                    {
                        item.push_back(c);
                    }
                }
                if (!item.empty())
                {
                    result.push_back(item);
                }
            }
            else
            {
                std::stringstream ss(s);
                while (std::getline(ss, item, delim))
                {
                    result.push_back(item);
                }
            }
            if (!s.empty() && s.back() == delim)
            {
                result.push_back("");
            }
            return result;
        }
 
        template<typename T>
        CORE_API T ltrim(const T& s, const char* to_remove = " \t\r\n")
        {
            size_t start = s.find_first_not_of(to_remove);
 
            if (start != std::string::npos)
            {
                return s.substr(start, s.size() - start);
            }
            else
            {
                return "";
            }
        }
 
        template<typename T>
        CORE_API T rtrim(const T& s, const char* to_remove = " \t\r\n")
        {
            size_t end = s.find_last_not_of(to_remove);
 
            if (end != std::string::npos)
            {
                return s.substr(0, end + 1);
            }
            else
            {
                return "";
            }
        }
 
        template<typename T>
        CORE_API T trim(const T& s, const char* to_remove = " \t\r\n")
        {
            size_t start = s.find_first_not_of(to_remove);
            size_t end   = s.find_last_not_of(to_remove);
 
            if (start != T::npos)
            {
                return s.substr(start, end - start + 1);
            }
            else
            {
                return "";
            }
        }
 
        template<typename T>
        CORE_API T replace(const T& str, const T& search, const T& replace)
        {
            auto s     = str;
            size_t pos = 0;
 
            if (search.empty())
            {
                return str;
            }
 
            while ((pos = s.find(search, pos)) != T::npos)
            {
                s.replace(pos, search.length(), replace);
                pos += replace.length();
            }
 
            return s;
        }
 
        template<typename Iterator, class Transform>
        CORE_API std::string join(const std::string& joiner, const Iterator& begin, const Iterator& end, const Transform& transform)
        {
            std::stringstream ss;
            bool first = true;
            for (auto it = begin; it != end; ++it)
            {
                if (!first)
                {
                    ss << joiner;
                }
                first = false;
                ss << transform(*it);
            }
            return ss.str();
        }
 
        template<typename T, class Transform>
        CORE_API std::string join(const std::string& joiner, const T& items, const Transform& transform)
        {
            return join(joiner, items.begin(), items.end(), transform);
        }
 
        template<typename T>
        CORE_API std::string join(const std::string& joiner, const T& items)
        {
            return join(joiner, items.begin(), items.end(), [](const auto& v) { return v; });
        }
 
        template<typename T>
        CORE_API T to_upper(const T& s)
        {
            T result = s;
            std::transform(result.begin(), result.end(), result.begin(), [](char c) { return std::toupper(c); });
            return result;
        }
 
        template<typename T>
        CORE_API T to_lower(const T& s)
        {
            T result = s;
            std::transform(result.begin(), result.end(), result.begin(), [](char c) { return std::tolower(c); });
            return result;
        }
 
        template<typename T>
        CORE_API u32 num_of_occurrences(const T& s, const T& substr)
        {
            u32 num_of_occurrences = 0;
            auto position          = s.find(substr, 0);
 
            while (position != std::string::npos)
            {
                num_of_occurrences++;
                position = s.find(substr, position + 1);
            }
 
            return num_of_occurrences;
        }
 
        template<typename T, template<typename, typename...> class Container, typename... Args>
        CORE_API inline std::vector<T> to_vector(const Container<T, Args...>& container)
        {
            return std::vector<T>(container.begin(), container.end());
        }
 
        template<typename T, template<typename, typename...> class Container, typename... Args>
        CORE_API inline std::set<T> to_set(const Container<T, Args...>& container)
        {
            return std::set<T>(container.begin(), container.end());
        }
 
        template<typename T1, typename T2>
        CORE_API bool is_subset(const T1& subset, const T2& superset)
        {
            for (const auto& element : subset)
            {
                if (std::find(std::begin(superset), std::end(superset), element) == std::end(superset))
                {
                    return false;    // Element not found in superset
                }
            }
            return true;    // All elements found; subset is indeed a subset of superset
        }
 
        CORE_API bool file_exists(const std::string& filename);
 
        CORE_API bool folder_exists_and_is_accessible(const std::filesystem::path& path);
 
        CORE_API std::filesystem::path which(const std::string& name, const std::string& path = "");
 
        CORE_API std::filesystem::path get_binary_directory();
 
        CORE_API std::filesystem::path get_base_directory();
 
        CORE_API std::filesystem::path get_library_directory();
 
        CORE_API std::filesystem::path get_share_directory();
 
        CORE_API std::filesystem::path get_user_share_directory();
 
        CORE_API std::filesystem::path get_config_directory();
 
        CORE_API std::filesystem::path get_user_config_directory();
 
        CORE_API std::filesystem::path get_default_log_directory(std::filesystem::path source_file = "");
 
        CORE_API std::vector<std::filesystem::path> get_gate_library_directories();
 
        CORE_API std::vector<std::filesystem::path> get_plugin_directories();
 
        CORE_API std::filesystem::path get_first_directory_exists(std::vector<std::filesystem::path> path_hints);
 
        CORE_API std::filesystem::path get_file(std::string file_name, std::vector<std::filesystem::path> path_hints);
 
        CORE_API Result<std::filesystem::path> get_unique_temp_directory(const std::string& prefix = "", const u32 max_attempts = 5);
 
        CORE_API std::string get_open_source_licenses();
 
        class CORE_API RecursiveDirectoryRange
        {
        public:
            using iterator = std::filesystem::recursive_directory_iterator;
 
            RecursiveDirectoryRange(std::filesystem::path path) : p_(path)
            {
            }
 
            iterator begin()
            {
                return std::filesystem::recursive_directory_iterator(p_);
            }
 
            iterator end()
            {
                return std::filesystem::recursive_directory_iterator();
            }
 
        private:
            std::filesystem::path p_;
        };
 
        class CORE_API DirectoryRange
        {
        public:
            using iterator = std::filesystem::directory_iterator;
 
            DirectoryRange(std::filesystem::path path) : p_(path)
            {
            }
 
            iterator begin()
            {
                return std::filesystem::directory_iterator(p_);
            }
 
            iterator end()
            {
                return std::filesystem::directory_iterator();
            }
 
        private:
            std::filesystem::path p_;
        };
 
        struct CORE_API Color
        {
            int h;
            int s;
            int v;
 
            Color(int _h = 0, int _s = 0, int _v = 0) : h(_h), s(_s), v(_v)
            {
            }
 
            std::string toString()
            {
                return "h=" + std::to_string(h) + " s=" + std::to_string(s) + " v=" + std::to_string(v);
            }
        };
 
        CORE_API Result<u64> wrapped_stoull(const std::string& s, const u32 base = 10);
 
        CORE_API Result<u32> wrapped_stoul(const std::string& s, const u32 base = 10);
    }    // namespace utils
}    // namespace hal