Compiler Explorer

Source code

#include <algorithm>
#include <cassert>
#include <concepts>
#include <cstdint>
#include <functional>
#include <iostream>
#include <iterator>
#include <ranges>
#include <span>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>

// A counterpart to std::same as that compares the underlying types.
// Suitable for checking the value types of ranges.
template<typename T, typename U>
concept different_from = !std::same_as<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;

// Dereferences a multi-dimensional range by one level.
template<std::ranges::input_range T>
using row_t = std::remove_cvref_t<std::ranges::range_value_t<T>>;

// Dereferences a multi-dimensional range by two levels.
template<class T>
    requires (std::ranges::input_range<T> &&
              std::ranges::input_range<row_t<T>>)
using column_t = std::remove_cvref_t<
    std::ranges::range_value_t<
        std::ranges::range_value_t<T>>>;

// A range whose elements can be moved.
template<class T, typename BasicConcreteData>
concept container_of_movable =
    std::ranges::input_range<T> &&
    std::indirectly_movable<std::ranges::iterator_t<T>, BasicConcreteData*>;

// For a visitor

template <typename... Ts>
struct Overload : Ts...
{
	using Ts::operator()...;
};
template <class... Ts>
Overload(Ts...) -> Overload<Ts...>;

enum class RequestErrors : uint8_t
{
	OK,
	NOT_FOUND,
	NOT_STRING,
	TOO_MANY_INPUTS,
	TOO_FEW_INPUTS,
	NOT_NUMERIC,

};

//
//  Data types
//

using BasicReferenceData = std::variant<std::string_view, std::span<std::uint8_t>>;
using BasicConcreteData = std::variant<std::string, std::vector<uint8_t>>;
std::span<std::uint8_t> t;
using ConcreteDataContainer = std::vector<BasicConcreteData>;
using ReferenceDataContainer = std::vector<BasicReferenceData>;

constexpr ReferenceDataContainer ReferenceFactory(const char* str) { return ReferenceDataContainer{std::string_view{str}}; }
constexpr ReferenceDataContainer ReferenceFactory(const char *str, size_t len) { return ReferenceDataContainer{std::string_view{str, len}}; }
constexpr ReferenceDataContainer ReferenceFactory(const std::string &str) { return ReferenceDataContainer{std::string_view(str)}; }
constexpr ReferenceDataContainer ReferenceFactory(const std::string_view sv) { return ReferenceDataContainer{sv}; }
constexpr ReferenceDataContainer ReferenceFactory(std::vector<uint8_t> &vec) { return ReferenceDataContainer{std::span<uint8_t>{vec.begin(), vec.size()}};}
constexpr ReferenceDataContainer ReferenceFactory(std::span<uint8_t> span) {return ReferenceDataContainer{span};}
constexpr ReferenceDataContainer ReferenceFactory(std::initializer_list<BasicReferenceData> list) {return ReferenceDataContainer(list); }
constexpr ReferenceDataContainer ReferenceFactory(const ReferenceDataContainer &ref) { return ReferenceDataContainer(ref); }

// // Initialize a list from a range of byte ranges:
// template<class T> requires (
//     std::convertible_to<column_t<T>, std::uint8_t> &&
//     different_from<column_t<T>, char>)
// constexpr ReferenceDataContainer ReferenceFactory(const T& source) {
//     ReferenceDataContainer rv;
//     rv.reserve(std::ranges::size(source));
//     for (const auto& x : source) {
//         rv.emplace_back(std::span<std::uint8_t>{std::ranges::begin(x), std::ranges::end(x)});
//     }
//     return rv;
// }

// Initializes a list from a container of BasicConcreteData
template<class T> requires
    std::same_as<row_t<T>, BasicConcreteData>
constexpr ReferenceDataContainer ReferenceFactory(const T& source) {
    ReferenceDataContainer rv;
    rv.reserve(std::ranges::size(source));
    for (const auto& x : source) {
        if (std::holds_alternative<std::string>(x)) {
            rv.emplace_back(std::string{std::get<std::string>(x)});
        } else if (std::holds_alternative<std::vector<std::uint8_t>>(x)) {
            const auto vector = std::get<std::vector<std::uint8_t>>(x);
            rv.emplace_back(std::span<std::uint8_t>{vector.begin(), vector.end()});
        } else { // Unreachable!
            std::cout.flush(); // Don't cross the streams!
            std::cerr << "Logic Error: a BasicReferenceData held an impossible type!\n";
            std::abort();
        }
    }
    return rv;
}

class ReferenceData : public ReferenceDataContainer
{
};

class ConcreteData : public ConcreteDataContainer
{
public:
            constexpr const ConcreteDataContainer getVector() const noexcept {
                return *static_cast<const ConcreteDataContainer*>(this);
            }
            constexpr       ConcreteDataContainer getVector() noexcept {
                return *static_cast<ConcreteDataContainer*>(this);
            }
            constexpr   void swap(ConcreteData& other) noexcept {
                swap(other);
            }

// Initializes a list from a range of moveable objects
            template<class T> requires
                container_of_movable<T, BasicConcreteData>
            constexpr   ConcreteData(T&& source) {
                for (auto&& x : source) {
                   emplace_back(std::move(x));
                }
            }
                        ConcreteData()                      = default;
                        ConcreteData(const ConcreteData&)   = default;
                        ConcreteData(ConcreteData&&)        = default;
                        ConcreteData&   operator=(const ConcreteData&)          = default;
                        ConcreteData&   operator=(ConcreteData&&)               = default;
                        bool            operator==(const ConcreteData&) const   = default;
                        bool            operator==(const ConcreteDataContainer& other){
                            return *this == other;
                        };

~ConcreteData()     = default; // Needs to be virtual if this is a base class.
};

constexpr void swap(ConcreteData& x, ConcreteData& y) noexcept {
    x.swap(y);
}

constexpr bool operator==(const ConcreteData& left, const ConcreteDataContainer& right) noexcept {
    return left.getVector() == right;
}

constexpr bool operator==(const ConcreteDataContainer& left, const ConcreteData& right) noexcept {
    return left == right.getVector();
}

ConcreteDataContainer ConcreteFactory(const char* str, size_t len) {
    return ConcreteDataContainer{std::string{str, len}};
}
ConcreteDataContainer ConcreteFactory(const char* str) {
    return ConcreteDataContainer{std::string{str}};
}
ConcreteDataContainer ConcreteFactory(std::string_view sv) {
    return ConcreteDataContainer{std::string(sv)};
}
ConcreteDataContainer ConcreteFactory(std::string&& str) {
    return ConcreteDataContainer{std::move(str)};
}
ConcreteDataContainer ConcreteFactory(std::vector<std::uint8_t>&& vec) {
    return ConcreteDataContainer{std::move(vec)};
}
constexpr ConcreteDataContainer ConcreteFactory(std::initializer_list<BasicConcreteData> list) { 
    return ConcreteDataContainer{list};
}
constexpr ConcreteDataContainer ConcreteFactory(ConcreteDataContainer &&ref) {
  return ConcreteDataContainer{std::move(ref)};  
}

template<std::size_t N>
constexpr ConcreteDataContainer ConcreteFactory(const char (&str)[N]) {
    return ConcreteDataContainer{std::string{str, N}};
}
// // Initialize a singleton list from a range of bytes:
// template<class T>
//     requires (std::ranges::input_range<T> &&
//                 std::convertible_to<row_t<T>, std::uint8_t> &&
//                 !std::convertible_to<T, std::string_view> &&
//                 different_from<T, ConcreteDataContainer> &&
//                 different_from<T, ConcreteData>)
// constexpr ConcreteDataContainer ConcreteFactory(const T& source)
// {
//     return ConcreteDataContainer{std::vector<std::uint8_t>{std::ranges::begin(source), std::ranges::end(source)}};
// }
ConcreteDataContainer ConcreteFactory(const std::span<std::uint8_t>& vec) {
    return ConcreteDataContainer{std::vector<std::uint8_t>(vec.begin(), vec.end())};
}

// Initialize a list from a range of byte ranges:
template<class T> requires (
    std::convertible_to<column_t<T>, std::uint8_t> &&
    different_from<column_t<T>, char>)
constexpr ConcreteDataContainer ConcreteFactory(const T& source) {
    ConcreteDataContainer rv;
    rv.reserve(std::ranges::size(source));
    for (const auto& x : source) {
        rv.emplace_back(std::vector<std::uint8_t>{std::ranges::begin(x), std::ranges::end(x)});
    }
    return rv;
}

// Initializes a list from a range of stringy types:
template<class T> requires
    std::same_as<column_t<T>, char>
constexpr ConcreteDataContainer ConcreteFactory(const T& source) {
    ConcreteDataContainer rv;
    rv.reserve(std::ranges::size(source));
    for (const auto& x : source) {
        rv.emplace_back(std::string{std::ranges::begin(x), std::ranges::end(x)});
    }
    return rv;
}

// Initializes a list from a range of BasicConcreteData
template<class T> requires
    std::same_as<row_t<T>, BasicConcreteData>
constexpr ConcreteDataContainer ConcreteFactory(const T& source) {
    ConcreteDataContainer rv;
    rv.reserve(std::ranges::size(source));
    for (const auto& x : source) {
        rv.emplace_back(x);
    }
    return rv;
}

// Initializes a list from a container of BasicReferenceData
template<class T> requires
    // std::same_as<row_t<T>, BasicReferenceData>
    std::same_as<row_t<T>, BasicReferenceData>
constexpr ConcreteDataContainer ConcreteFactory(const T& source) {
    ConcreteDataContainer rv;
    rv.reserve(std::ranges::size(source));
    for (const auto& x : source) {
        if (std::holds_alternative<std::string_view>(x)) {
            rv.emplace_back(std::string{std::get<std::string_view>(x)});
        } else if (std::holds_alternative<std::span<std::uint8_t>>(x)) {
            const auto span = std::get<std::span<std::uint8_t>>(x);
            rv.emplace_back(std::vector<std::uint8_t>{span.begin(), span.end()});
        } else { // Unreachable!
            std::cout.flush(); // Don't cross the streams!
            std::cerr << "Logic Error: a BasicReferenceData held an impossible type!\n";
            std::abort();
        }
    }
    return rv;
}

// // Initializes a list from a range of moveable objects
// template<class T> requires
//     container_of_movable<T, BasicConcreteData>
// constexpr ConcreteDataContainer&& ConcreteFactory(T&& source) {
//     ConcreteDataContainer rv;
//     rv.reserve(std::ranges::size(source));
//     for (auto&& x : source) {
//         rv.emplace_back(std::move(x));
//     }
//     return std::move(rv);
// }

using ReturnData = ConcreteData;
using RequestReturn = std::pair<RequestErrors, ReturnData>;
using CallbackSignature = std::function<RequestReturn(const std::string &context, const ReferenceData &)>;

///
///     Guarders
///

using PayloadGuardFN = std::function<RequestReturn(const ReferenceData&)>;

/*      Helper functions    */

bool binaryData(const BasicReferenceData& data) {
    return std::holds_alternative<std::span<std::uint8_t>>(data);
}
bool printable(const BasicReferenceData& in) {
    auto span = std::get_if<std::span<std::uint8_t>>(&in);
    return !span || std::all_of(span->begin(), span->end()-1, isprint) && (isprint(span->back()) || span->back() == 0);
    // !span means it's a string_view
}
void to_string(BasicReferenceData& data) { // Might remove the check.
    if (std::holds_alternative<std::span<std::uint8_t>>(data)) {
        auto span = std::get<std::span<std::uint8_t>>(data);
        data = BasicReferenceData{std::string_view(reinterpret_cast<char*>(span.data()), span.size())};
    }
}
void to_string(ReferenceDataContainer::iterator it) {
    if (binaryData(*it)) {
        auto span = std::get<std::span<std::uint8_t>>(*it);
        *it = BasicReferenceData{std::string_view(reinterpret_cast<char*>(span.data()), span.size())};
    }
}
bool is_number(std::string_view s)
{
    bool numeric = false;
    if (s.size()) {
        bool first_char_valid = numeric = (isdigit(s.front()) || (s.front() == '-' && s.size() > 1));
        if (first_char_valid) {
            bool found_dot = false;
            for (auto it = s.begin(); it != s.end(); it++) {
                if (isdigit(*it)) continue;
                else if (*it=='.' && !found_dot) {
                    found_dot = true;
                    continue;
                }
                numeric = false;
                break;
            }
        }
    }
    return numeric;
}

class Guarder {
    public:
    virtual RequestReturn operator()(const ReferenceData& in) = 0;
};

class CountGuarder : public Guarder { // Or a template ??
    size_t count;
public:
            RequestReturn operator()(const ReferenceData& in) override{ return std::make_pair((in.size() > count ?  std::cout << "TOO MANY!\n", RequestErrors::TOO_MANY_INPUTS : in.size() < count ?  std::cout << "TOO FEW!\n", RequestErrors::TOO_FEW_INPUTS : RequestErrors::OK), ReturnData{});}
    CountGuarder(size_t count) : count(count) {}
                            
};

class StringCorrectGuarder : public Guarder {
    public:
            RequestReturn operator()(const ReferenceData& in) override {
                auto mut_in = const_cast<ReferenceData*>(&in);
                // auto view = in | std::views::filter(binaryData);
                if (std::all_of(in.begin(), in.end(), printable)) {
                    for (auto it = mut_in->begin(); it != mut_in->end(); it++) {
                        if (binaryData(*it)) {
                            to_string(it);
                        }
                    }
                    // std::ranges::for_each(mut_in | std::views::filter(binaryData), to_string);
                    return std::make_pair(RequestErrors::OK, ConcreteData{});
                } else {
                    return std::make_pair(RequestErrors::NOT_STRING, ConcreteData{});
                }
            }
};

// Should follow a StringGuarder within the pipeline?
class NumericGuarder : public Guarder {
    public:
            RequestReturn operator()(const ReferenceData& in) override {
                StringCorrectGuarder stringify;
                auto result = stringify(in);
                if (result.first != RequestErrors::OK) {
                    return result;
                }
                for (auto& i : in) {
                    auto* sv = std::get_if<std::string_view>(&i);
                    if (!sv || !is_number(*sv))
                        std::cout << "Not Numeric!\n";
                        return std::make_pair(RequestErrors::NOT_NUMERIC, ConcreteFactory(*sv));
                    }
                return std::make_pair(RequestErrors::OK, ConcreteData{});
            }
};

// Can have Custom Guarder.

RequestReturn toStringCorrector(const ReferenceData& pload) {
    StringCorrectGuarder stringify;
    return stringify(pload);
}

//
//  SystemInterface
//

struct request {
    CallbackSignature cbf;
    std::vector<Guarder*> guarders;
};

class SystemInterface
{
	std::unordered_map<std::string, request> requests;

public:
	void addRequest(const std::string &name, CallbackSignature cbf, std::initializer_list<Guarder*> guarders={})
	{
		requests[name] = request{cbf, guarders};
	}
	RequestReturn execCmd(const std::string &name, const std::string &context, const ReferenceData &payload)
	{
		if (requests.count(name))
		{
		    auto& req=requests[name];
		    for(auto& guard : req.guarders) {
		        auto ret = (*guard)(payload);
		        if (ret.first!=RequestErrors::OK) {
		            return ret;
		        }
		    }
			return requests[name].cbf(context, payload);
		}
		return std::make_pair(RequestErrors::NOT_FOUND, ConcreteDataContainer{});
	}
};

//
// USER CODE
//

SystemInterface interface;

void printPayload(const ReferenceData& pload) {
	for (const auto &d : pload)
	{
		if (auto *pval = std::get_if<std::string_view>(&d))
		{
			std::cout << *pval << "\t[string_view]\n";
		}
		else if (auto* pval = std::get_if<std::span<uint8_t>>(&d)) {
		    std::cout << pval->data() << "\t[span<uint8_t>]\n";
		}
	}
}

CountGuarder c1Guard(1);
NumericGuarder nGuard;
StringCorrectGuarder sGuard;
using namespace std::literals::string_literals;
using namespace std::literals::string_view_literals;
using std::uint8_t;
#include <array>
static_assert(std::indirectly_movable<std::ranges::iterator_t<std::vector<std::vector<uint8_t>>&&>, std::vector<uint8_t>*>);

int main()
{
    constexpr char hello[] = "hello, world!";

const ConcreteData data1 = ConcreteFactory(hello);
    const ConcreteData dataList = ConcreteFactory({"hello"s,
                                   "world"s,
                                   std::vector<std::uint8_t>{1,2,3}});
    constexpr uint8_t matrix[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}};
    const ConcreteData dataMatrix = ConcreteFactory(matrix);
    constexpr std::string_view string_table[] = {"hello"sv, "world!"sv};
    const ConcreteData dataStrins = ConcreteFactory(string_table);
    const ConcreteData fromContainer = ConcreteDataContainer{"hello"s, "world"s};
    std::string tempArray[] = {"hello"s, "world"s};
    const ConcreteData fromTempArray = std::move(tempArray);
    uint8_t toSpan[] = {1, 2, 3};
    const ReferenceDataContainer refs = {"hello"sv,
                                         "world"sv,
                                         std::span<uint8_t>{toSpan}};
    const ConcreteData fromRefs = ConcreteFactory(refs);
    assert(fromRefs != ConcreteDataContainer{});
    assert(ConcreteDataContainer{} != fromRefs);
    const BasicReferenceData refArray[] = {"hello"sv,
                                      "world"sv,
                                      std::span<uint8_t>{toSpan}};
    const ConcreteData fromRefArray = ConcreteFactory(refArray);
    assert(fromRefs == fromRefArray);
    ConcreteData copyData = fromRefArray;
    const ConcreteData moveData = std::move(fromRefArray);
    std::array<std::uint8_t,10> array = {};
    ConcreteData arrayData{ConcreteFactory(array)};
    ReferenceData arrayRef{ReferenceFactory(array)};

uint8_t u_array[] = {1,2,3,4,5};
    ConcreteData u_arrayData{ConcreteFactory(u_array)};
    // std::array<std::uint8_t,5> to_move{1,2,3,4,5};
    // ConcreteData to_move_data {ConcreteFactory(std::move(to_move))};
    return EXIT_SUCCESS;
}
// int main()
// {
// 	interface.addRequest("hello", [](const std::string &ctx, const ReferenceData &pload)
// 						 {
//         // const std::string* input = std::get_if<std::string>(&pload);
//         std::cout << "pload size" << pload.size() << "\n";
//         auto DataVisiter = Overload {
//             [](const std::string_view&) { return "string_view"; },
//             [](const std::span<uint8_t>&) { return "span<uint8_t>"; },
//             [](auto) { return "unknown type"; },
//         };
//         for (const auto& d : pload) {
//             std::cout << "type: " << std::visit(DataVisiter, d) << "\n";
//             std::cout << std::get<std::string_view>(d) << "\n"; 
            
//             if(auto* pval = std::get_if<std::string_view>(&d)) {
//                 std::cout << *pval << "\n";
//             }
//         }

//        return std::make_pair(RequestErrors::OK,std::vector<BasicConcreteData>{std::string("HelloWorld")}); }, 
//                                                                                                     {&c1Guard, &sGuard});

// 	interface.addRequest("hi", [](const std::string &ctx, const ReferenceData &pload)
// 						 { return std::make_pair(RequestErrors::OK, std::vector<BasicConcreteData>{std::string("HelloWorld")}); });
// 	std::string data{"Hi"};
// 	ReferenceData rcont{data};
//     printPayload(rcont);

// 	auto [error, rets] = interface.execCmd("hello", "Ctx", std::string{"Hello"});
// 	if (error == RequestErrors::OK && rets.size())
// 	{
// 		if (auto *value = std::get_if<std::string>(&rets.front()))
// 		{
// 			std::cout << "Ret value: " << *value << std::endl;
// 		}
// 	}
	
// 	auto inputData = std::vector<uint8_t>{0x54,0x68,0x69,0x73,0x20,0x69,0x73,0x20,0x73,0x74,0x72,0x69,0x6E,0x67,0};
// 	auto payload = ReferenceData{inputData};
// 	printPayload(payload);
// 	auto ret = toStringCorrector(payload);
// 	printPayload(payload);

// 	return 0;
// }