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/rfnoc/chdr_types.hpp>
#include <boost/optional.hpp>
#include <memory>
#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,
        boost::optional<uint64_t> timestamp = boost::none,
        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,
        boost::optional<uint64_t> timestamp = boost::none,
        std::vector<uint64_t> mdata         = {});

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

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

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

    void set_timestamp(boost::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);

    const std::string to_string() const;

    template <typename payload_t>
    const 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;
    boost::optional<uint64_t> _timestamp;
    std::vector<uint64_t> _mdata;
};

}}} // namespace uhd::utils::chdr

#include <uhd/utils/chdr/chdr_packet.ipp>