chdr_packet.hpp

Go to the documentation of this file.

//
// Copyright 2020 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#pragma once
 
#include <uhd/config.hpp>
#include <uhd/rfnoc/chdr_types.hpp>
#include <uhd/rfnoc/rfnoc_types.hpp>
#include <uhd/types/endianness.hpp>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
namespace uhd { namespace utils { namespace chdr {

class UHD_API chdr_packet
{
public:
    template <typename payload_t>
    chdr_packet(uhd::rfnoc::chdr_w_t chdr_w,
        uhd::rfnoc::chdr::chdr_header header,
        payload_t payload,
        std::optional<uint64_t> timestamp = {},
        std::vector<uint64_t> metadata    = {});

    chdr_packet(uhd::rfnoc::chdr_w_t chdr_w,
        uhd::rfnoc::chdr::chdr_header header,
        std::vector<uint8_t> payload_data,
        std::optional<uint64_t> timestamp = {},
        std::vector<uint64_t> metadata    = {});

    uhd::rfnoc::chdr::chdr_header get_header() const;

    void set_header(uhd::rfnoc::chdr::chdr_header header);

    std::optional<uint64_t> get_timestamp() const;

    void set_timestamp(std::optional<uint64_t> timestamp);

    const std::vector<uint64_t>& get_metadata() const;

    void set_metadata(std::vector<uint64_t> metadata);

    std::vector<uint8_t> serialize_to_byte_vector(
        endianness_t endianness = uhd::ENDIANNESS_LITTLE) const;

    template <typename OutputIterator>
    void serialize(OutputIterator first,
        OutputIterator last,
        endianness_t endianness = uhd::ENDIANNESS_LITTLE) const;

    template <typename InputIterator>
    static chdr_packet deserialize(uhd::rfnoc::chdr_w_t chdr_w,
        InputIterator first,
        InputIterator last,
        endianness_t endianness = uhd::ENDIANNESS_LITTLE);

    size_t get_packet_len() const;

    const std::vector<uint8_t>& get_payload_bytes() const;

    void set_payload_bytes(std::vector<uint8_t> bytes);

    template <typename payload_t>
    payload_t get_payload(uhd::endianness_t endianness = uhd::ENDIANNESS_LITTLE) const;

    template <typename payload_t>
    void set_payload(
        payload_t payload, uhd::endianness_t endianness = uhd::ENDIANNESS_LITTLE);

    std::string to_string() const;

    template <typename payload_t>
    std::string to_string_with_payload(
        uhd::endianness_t endianness = uhd::ENDIANNESS_LITTLE) const;
 
private:
    void serialize_ptr(endianness_t endianness, void* start, void* end) const;
 
    static chdr_packet deserialize_ptr(uhd::rfnoc::chdr_w_t chdr_w,
        endianness_t endianness,
        const void* start,
        const void* end);
 
    inline void set_header_lengths()
    {
        _header.set_num_mdata(_mdata.size() / (uhd::rfnoc::chdr_w_to_bits(_chdr_w) / 64));
        _header.set_length(get_packet_len());
    }
 
    uhd::rfnoc::chdr_w_t _chdr_w;
    uhd::rfnoc::chdr::chdr_header _header;
    std::vector<uint8_t> _payload;
    std::optional<uint64_t> _timestamp;
    std::vector<uint64_t> _mdata;
};
 
}}} // namespace uhd::utils::chdr
 
#include <uhd/utils/chdr/chdr_packet.ipp>