TM_Tools.h

Go to the documentation of this file.

 
#ifndef _TM_TOOLS_H
#define _TM_TOOLS_H
 
#include <variant>
#include <json.hpp>
#include <vector>
#include <unordered_map>
#include <mutex>
#include <fstream>
#include <iostream>
#include <string>
#include <filesystem>
#include <sstream>
 
/*
 * Types definitions and tools to use them inside TailorMade
 * These functions have to be update for each new type.
 */
#include <cctype>
 
// Types and operators
typedef struct Vector2 { float x; float y; 

    Vector2 operator+(const Vector2 v2) const {
        return { x + v2.x, y + v2.y };
    }

    Vector2 operator-(const Vector2 v2) const {
        return { x - v2.x, y - v2.y };
    }

    float operator*(const Vector2 v2) const {
        return x * v2.x + y * v2.y;
    }

    Vector2 operator*=(const float s) const {
        return { x * s, y * s };
    }

    Vector2 operator/=(const float s) const {
        return { x / s, y / s };
    }

    float operator!() const {
        return sqrt(x * x + y * y);
    }

    Vector2 operator~() const {
        float norm = !(*this);
        return { x / norm, y / norm };
    }

    float operator%(const Vector2 v2) const {
        float norm1 = !(*this);
        float norm2 = !v2;
        return acos(((*this) * v2) / (norm1 * norm2));
    }

    Vector2 operator>>(const Vector2 v2) const {
        float norm2 = !v2;
        norm2 *= norm2; // Squared the norm
        float dotProd = (*this) * v2;
        return (*this) *= (dotProd / norm2);
    }
} Vector2;

typedef struct Vector3 { float x; float y; float z; 

    Vector3 operator+(const Vector3 v2) const {
        return { x + v2.x, y + v2.y, z + v2.z };
    }

    Vector3 operator-(const Vector3 v2) const {
        return { x - v2.x, y - v2.y, z - v2.z };
    }

    float operator*(const Vector3 v2) const {
        return x * v2.x + y * v2.y + z * v2.z;
    }

    Vector3 operator*=(const float s) const {
        return { x * s, y * s, z * s };
    }
    
    Vector3 operator/=(const float s) const {
        return { x / s, y / s, z / s };
    }

    Vector3 operator^(const Vector3 v2) const {
        return { y * v2.z - z * v2.y, z * v2.x - x * v2.z, x * v2.y - y * v2.x };
    }

    float operator!() const {
        return sqrt(x * x + y * y + z * z);
    }

    Vector3 operator~() const {
        float norm = !(*this);
        return { x / norm, y / norm, z / norm };
    }

    float operator%(const Vector3 v2) const {
        float norm1 = !(*this);
        float norm2 = !v2;
        return acos(((*this) * v2) / (norm1 * norm2));
    }

    Vector3 operator>>(const Vector3 v2) const {
        float norm2 = !v2;
        norm2 *= norm2; // Squared the norm
        float dotProd = (*this) * v2;
        return (*this) *= (dotProd / norm2);
    }
} Vector3;

inline std::ostream& operator<<(std::ostream& os, const Vector2& v) {
    os << "{ x: " << v.x << ", y: " << v.y << "}";
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const Vector3& v) {
    os << "{ x: " << v.x << ", y: " << v.y << ", z: " << v.z << "}";
    return os;
}

#define ECS_Types int, float, std::string, bool, Vector2, Vector3

using dataUnMap = std::unordered_map<std::string, std::pair<std::string, std::variant<ECS_Types>>>;

using dataVector = std::vector<std::pair<std::string, std::variant<ECS_Types>>>;

std::variant<ECS_Types> strToType(std::string type);

std::variant<ECS_Types> valueToType(const nlohmann::json& value, std::string type);

nlohmann::ordered_json serializeType(const dataUnMap& data);

void valueToStream(std::ostream& stream, std::variant<ECS_Types> value);

std::vector<std::string> getAllFilesFromDirectory(const std::string& directory);
 
inline std::variant<ECS_Types> strToType(std::string type) {
    // This function return the default value for the given type.
    // We authorize the first letter to be an upper or lower case, the others must be lower case exclusively.
    // There is the common variations for most of the types.
 
    type[0] = tolower(static_cast<unsigned char>(type[0]));
 
    if (type == "integer" || type == "int") {
        return 0;
    }
    else if (type == "float") {
        return 0.0f;
    }
    else if (type == "string" || type == "str") {
        return "";
    }
    else if (type == "boolean" || type == "bool") {
        return false;
    }
    else if (type == "vector2") {
        return Vector2({ 0.0f, 0.0f });
    }
    else if (type == "vector3") {
        return Vector3({ 0.0f, 0.0f, 0.0f });
    }
 
    throw std::runtime_error("Error : invalid type \"" + type + "\".");
}
 
inline std::variant<ECS_Types> valueToType(const nlohmann::json& value, std::string type) {
    // This function return the variant from the given type with the given value.
    type[0] = tolower(static_cast<unsigned char>(type[0]));
 
    if (type == "integer" || type == "int") {
        return value.get<int>();
    }
    else if (type == "float") {
        return value.get<float>();
    }
    else if (type == "string" || type == "str") {
        return value.get<std::string>();
    }
    else if (type == "boolean" || type == "bool") {
        return value.get<bool>();
    }
    else if (type == "vector2") {
        return Vector2{ value[0].get<float>(), value[1].get<float>() };
    }
    else if (type == "vector3") {
        return Vector3{ value[0].get<float>(), value[1].get<float>(), value[2].get<float>() };
    }
 
    throw std::runtime_error("Error : invalid type \"" + type + "\".");
}
 
inline nlohmann::ordered_json serializeType(const dataUnMap& dataMap) {
    nlohmann::ordered_json dict = nlohmann::ordered_json::object();
 
    for (const auto& [key, valuePair] : dataMap) {
        const auto& data = valuePair.second;
 
        // Fast way to visit all the possibility.
        std::visit([&](auto&& val) {
            using T = std::decay_t<decltype(val)>;
 
            if constexpr (std::is_same_v<T, int> ||
                std::is_same_v<T, float> ||
                std::is_same_v<T, std::string> ||
                std::is_same_v<T, bool>) {
                dict[key] = val; // int, float, string, bool
            }
            else if constexpr (std::is_same_v<T, Vector2>) {
                dict[key] = { val.x, val.y };
            }
            else if constexpr (std::is_same_v<T, Vector3>) {
                dict[key] = { val.x, val.y, val.z };
            }
        }, data);
    }
    return dict;
}
 
inline void valueToStream(std::ostream& stream, std::variant<ECS_Types> value) {
    // Fast way to add to stream.
    std::visit([&](auto&& val) {
            stream << val;
    }, value);
}
 
inline std::vector<std::string> getAllFilesFromDirectory(const std::string& directory) {
    std::vector<std::string> result;
 
    try {
        for (const auto& file : std::filesystem::recursive_directory_iterator(directory)) {
            if (std::filesystem::is_regular_file(file.path())) { // Only the files
                result.push_back(file.path().string());
            }
        }
    }
    catch (const std::filesystem::filesystem_error& e) {
        std::cerr << e.what() << std::endl;
    }
 
    return result;
}
 
#endif //_TM_TOOLS_H