Compiler Explorer

Source code

#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 Data>
concept container_of_movable =
    std::ranges::input_range<T> &&
    std::indirectly_movable<std::ranges::iterator_t<T>, Data*>;

enum class RequestErrors : uint8_t
{
    OK,
    NOT_FOUND,

};
using DataReference = std::variant<std::string_view, std::span<uint8_t>>;
using Data = std::variant<std::string, std::vector<std::uint8_t>>;

using DataReferenceContainer = std::vector<DataReference>;
using DataContainer = std::vector<Data>;

class RequestPayload
{
    DataReferenceContainer ploads;

public:
            std::size_t         size()          const { return ploads.size(); };
            auto                begin()         const { return ploads.begin(); }
            auto                end()           const { return ploads.end(); }
            auto&               front()         const { return ploads.front(); }
            auto&               back()          const { return ploads.back(); }

auto&               getVector()     const { return ploads; }

RequestPayload() = default;
    RequestPayload(const RequestPayload&) = default;
    RequestPayload(RequestPayload&&) = default;
    RequestPayload& operator=(const RequestPayload&) = default;
    RequestPayload& operator=(RequestPayload&&) = default;
    ~RequestPayload() = default; // Must be virtual if you intend to make this a base class.

RequestPayload(const char *str) : ploads(DataReferenceContainer{std::string_view{str}}) {}
    RequestPayload(const char *str, size_t len) : ploads(DataReferenceContainer{std::string_view{str, len}}) {}
    RequestPayload(const std::string &str) : ploads(DataReferenceContainer{str}) {}
    RequestPayload(const std::string_view sv) : ploads(DataReferenceContainer{sv}) {}
    RequestPayload(std::vector<uint8_t> &vec) : ploads(DataReferenceContainer{std::span<uint8_t>{vec.begin(), vec.size()}}) {}
    RequestPayload(std::span<uint8_t> span) : ploads(DataReferenceContainer{span}) {}
    RequestPayload(std::initializer_list<DataReference> list) : ploads(list) {}
    RequestPayload(const DataReferenceContainer &ref) : ploads(ref) {}
};

class ConcreteData
{
    DataContainer rets;

public:
    using iterator        = typename decltype(rets)::iterator;
    using const_iterator  = typename decltype(rets)::const_iterator;
    using pointer         = typename decltype(rets)::pointer;
    using const_pointer   = typename decltype(rets)::const_pointer;
    using reference       = typename decltype(rets)::reference;
    using const_reference = typename decltype(rets)::const_reference;
    using value_type      = typename decltype(rets)::value_type;

constexpr std::size_t     size() const noexcept { return rets.size(); };
    constexpr iterator        begin() noexcept {return rets.begin();}
    constexpr const_iterator  begin() const noexcept { return rets.begin(); }
    constexpr iterator        end() noexcept {return rets.end();}
    constexpr const_iterator  end() const noexcept  { return rets.end(); }
    constexpr reference       front() noexcept { return rets.front(); }
    constexpr const_reference front() const noexcept { return rets.front(); }
    constexpr reference       back() noexcept { return rets.back(); }
    constexpr const_reference back() const noexcept { return rets.back(); }
    constexpr pointer         data() noexcept {return rets.data();}
    constexpr const_pointer   data() const noexcept {return rets.data();}
    constexpr auto&           getvector() noexcept { return rets; }
    constexpr const auto&     getVector() const noexcept { return rets; }    // TODO: You should implement the rest of the container interface.
    // TODO: You should implement all of the container interface.

ConcreteData() = default;
    ConcreteData(const ConcreteData&) = default;
    ConcreteData(ConcreteData&&) = default;
    explicit constexpr ConcreteData(const char *str, size_t len) : rets{std::string{str, len}} {}
    explicit constexpr ConcreteData(const char *str) : rets{std::string{str}} {}
    constexpr ConcreteData(std::initializer_list<Data> list) : rets{list} {}
    explicit constexpr ConcreteData(DataContainer &&ref) : rets{std::move(ref)} {}
    constexpr ConcreteData(const std::string_view str) : rets{std::string{str}} {}
    explicit constexpr ConcreteData(std::string&& str) : rets{std::move(str)} {}
    explicit constexpr ConcreteData(std::vector<std::uint8_t>&& vec) : rets{std::move(vec)} {}

template<std::size_t N>
    constexpr ConcreteData(const char (&str)[N]) : rets{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, DataContainer> &&
                  different_from<T, ConcreteData>)
    constexpr ConcreteData(const T& source)
     : rets{std::vector<std::uint8_t>{std::ranges::begin(source), std::ranges::end(source)}}
    {}

// 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 ConcreteData(const T& source) {
        for (const auto& x : source) {
            rets.emplace_back(std::vector<std::uint8_t>{std::ranges::begin(x), std::ranges::end(x)});
        }
    }

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

// Initializes a list from a range of Data
    template<class T> requires
        std::same_as<row_t<T>, Data>
    constexpr ConcreteData(const T& source) {
        for (const auto& x : source) {
            rets.emplace_back(x);
        }
    }

// Initializes a list from a container of DataReference
    template<class T> requires
        std::same_as<row_t<T>, DataReference>
    constexpr ConcreteData(const T& source) {
        for (const auto& x : source) {
            if (std::holds_alternative<std::string_view>(x)) {
                rets.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);
                rets.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 DataReference held an impossible type!\n";
                std::abort();
            }
        }
    }

// Initializes a list from a range of moveable objects
    template<class T> requires
        container_of_movable<T, Data>
    constexpr ConcreteData(T&& source) {
        for (auto&& x : source) {
           rets.emplace_back(std::move(x));
        }
    }

constexpr void swap(ConcreteData& other) noexcept {
        rets.swap(other.rets);
    }

ConcreteData& operator=(const ConcreteData&) = default;
    ConcreteData& operator=(ConcreteData&&) = default;
    bool operator==(const ConcreteData&) const = default;
    ~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 DataContainer& right) noexcept {
    return left.getVector() == right;
}

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

using ReturnData = ConcreteData;
using RequestReturn = std::pair<RequestErrors, ReturnData>;

using CallbackSignature = std::function<RequestReturn(const std::string &context, const RequestPayload &)>;

/* Simplified SystemInterface */
class SystemInterface
{
    std::unordered_map<std::string, CallbackSignature> requests;

public:
    void addRequest(const std::string &name, CallbackSignature cbf)
    {
        requests[name] = cbf;
    }
    RequestReturn execCmd(const std::string &name, const std::string &context, const RequestPayload &payload)
    {
        if (requests.count(name))
        {
            return requests[name](context, payload);
        }
        return std::make_pair(RequestErrors::NOT_FOUND, ConcreteData{});
    }
};

using namespace std::literals::string_literals;
using namespace std::literals::string_view_literals;
using std::uint8_t;

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 = hello;
    const ConcreteData dataList = {"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 = matrix;
    constexpr std::string_view string_table[] = {"hello"sv, "world!"sv};
    const ConcreteData dataStrins = string_table;
    const ConcreteData fromContainer = DataContainer{"hello"s, "world"s};
    std::string tempArray[] = {"hello"s, "world"s};
    const ConcreteData fromTempArray = std::move(tempArray);
    uint8_t toSpan[] = {1, 2, 3};
    const DataReferenceContainer refs = {"hello"sv,
                                         "world"sv,
                                         std::span<uint8_t>{toSpan}};
    const ConcreteData fromRefs = refs;
    assert(fromRefs != DataContainer{});
    assert(DataContainer{} != fromRefs);
    const DataReference refArray[] = {"hello"sv,
                                      "world"sv,
                                      std::span<uint8_t>{toSpan}};
    const ConcreteData fromRefArray = refArray;
    assert(fromRefs == fromRefArray);
    ConcreteData copyData = fromRefArray;
    const ConcreteData moveData = std::move(fromRefArray);

return EXIT_SUCCESS;
}