utils.hpp

Go to the documentation of this file.

 
#ifndef CORE_PROTOCOL_BASE_UTILS_HPP
#define CORE_PROTOCOL_BASE_UTILS_HPP
 
#include <sstream>
#include <ostream>
#include <string>
#include <vector>
 
#include <boost/variant.hpp>
 
namespace ifw::core::protocol::base {
 
    // Visitor class to convert the value of the variant to an std::string
    class VariantStr {
public:
    // Overload for scalar types other than char
    template <typename T>
    std::string operator()(const T& value) const {
        if constexpr (std::is_same_v<T, std::string>) {
            return "[scalar type: std::string]= " + value;
        } else {
            return "[scalar type: " + demangle_type<T>() + "]= " + std::to_string(value);
        }
    }
 
    // Special handling for std::vector<T>
    template <typename T>
    std::string operator()(const std::vector<T>& vec) const {
 
        std::ostringstream oss;
        oss << "[vector type: " << demangle_type<T>() << "]= {";
 
        for (size_t i = 0; i < vec.size(); ++i) {
            if (i != 0) oss << ", ";
            oss << (*this)(vec[i]);   // Recursive processing of elements
        }
 
        oss << "}";
        return oss.str();
    }
 
private:
    template <typename T>
    std::string demangle_type() const {
        return boost::core::demangle(typeid(T).name());
        // If you want full standard C++ without Boost, I can also replace this.
    }
};
 
class VariantValue {
public:
    // Overload for scalar types
    template <typename T>
    std::string operator()(const T& value) const {
        if constexpr (std::is_same_v<T, std::string>) {
            return value;
        } else {
            return std::to_string(value);
        }
    }
 
    // Special handling for vector types
    template <typename T>
    std::string operator()(const std::vector<T>& vec) const {
 
        std::ostringstream oss;
 
        for (size_t i = 0; i < vec.size(); ++i) {
            if (i != 0) oss << ", ";
            oss << (*this)(vec[i]);   // recursive call
        }
 
        return oss.str();
    }
};
 
 
  }
 
#endif //CORE_PROTOCOL_BASE_UTILS_HPP