bundle.hpp

Go to the documentation of this file.

#pragma once
 
// OSC Bundle — timetag + nested messages/bundles per OSC 1.0 spec.
 
#include <pulp/osc/osc.hpp>
#include <vector>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <variant>
 
namespace pulp::osc {

struct TimeTag {
    uint32_t seconds = 0;
    uint32_t fraction = 0;

    static TimeTag immediate() { return {0, 1}; }

    static TimeTag from_unix(double unix_time);

    double to_unix() const;
 
    bool operator==(const TimeTag& o) const {
        return seconds == o.seconds && fraction == o.fraction;
    }
};
 
struct Bundle;  // forward declaration

struct BundleElement {
    std::variant<Message, std::unique_ptr<Bundle>> content;
 
    BundleElement() = default;

    explicit BundleElement(Message msg) : content(std::move(msg)) {}

    explicit BundleElement(std::unique_ptr<Bundle> b) : content(std::move(b)) {}

    explicit BundleElement(Bundle b);
 
    bool is_message() const { return std::holds_alternative<Message>(content); }
    bool is_bundle() const { return std::holds_alternative<std::unique_ptr<Bundle>>(content); }
 
    const Message& message() const { return std::get<Message>(content); }
    const Bundle& bundle() const { return *std::get<std::unique_ptr<Bundle>>(content); }
};

struct Bundle {
    TimeTag timetag = TimeTag::immediate();
    std::vector<BundleElement> elements;

    void add(Message msg) {
        elements.emplace_back(std::move(msg));
    }

    void add(Bundle nested) {
        elements.emplace_back(std::make_unique<Bundle>(std::move(nested)));
    }

    std::vector<uint8_t> serialize() const;

    static std::optional<Bundle> deserialize(const uint8_t* data, size_t size);
};

inline BundleElement::BundleElement(Bundle b)
    : content(std::make_unique<Bundle>(std::move(b))) {}

bool address_matches(std::string_view pattern, std::string_view address);
 
}  // namespace pulp::osc