agnosticDataSamples.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_TELSUB_AGNOSTICDATASAMPLES_HPP
#define RTCTK_TELSUB_AGNOSTICDATASAMPLES_HPP
#include <rtctk/config.hpp>
 
#include <cassert>
#include <iostream>
#include <memory_resource>
#include <system_error>
#include <vector>
 
#include <rtctk/componentFramework/dds.hpp>
 
namespace rtctk::telSub {
 
// Alias of the DDS topic type used throughout telSub
using DdsSample = rtctk::AgnosticTopic;
using DdsSampleSeq = rtctk::AgnosticTopicSeq;
 
using DdsInfoSeq = SampleInfoSeq;
 
class SeqLoanerIf {
public:
    virtual std::error_code
    ReturnLoan(std::uint8_t idx, DdsSampleSeq& samples, DdsInfoSeq& infos) RTCTK_NOEXCEPT = 0;
};
 
class AgnosticDataSamples {
public:
    using Alloc = std::pmr::polymorphic_allocator<std::byte>;
 
    AgnosticDataSamples(std::uint8_t size, SeqLoanerIf& loaner, Alloc const& alloc = {});
    ~AgnosticDataSamples() noexcept;
 
    AgnosticDataSamples(AgnosticDataSamples const&) = delete;
    AgnosticDataSamples& operator=(AgnosticDataSamples const&) = delete;
 
 
    inline std::uint8_t Size() const noexcept {
        return m_samples.size();
    }
 
    inline DdsSampleSeq const& operator[](std::uint8_t idx) const noexcept {
        assert(idx < Size());
        return m_samples[idx];
    }
 
    inline DdsSampleSeq& operator[](std::uint8_t idx) noexcept {
        assert(idx < Size());
        return m_samples[idx];
    }
 
    inline DdsSampleSeq const& At(std::uint8_t idx) const {
        if (idx < Size()) {
            return this->operator[](idx);
        }
        throw std::out_of_range("idx is out of range");
    }
 
    inline bool Empty() const noexcept;
 
    inline bool Full() const noexcept;
 
 
    inline std::tuple<DdsSampleSeq&, DdsInfoSeq&> GetUpdateRefs(std::uint8_t idx) noexcept {
        assert(idx < Size());
        return {m_samples[idx], m_infos[idx]};
    }
 
    inline void Clear(std::uint8_t idx) noexcept;
 
    inline void Clear() noexcept;
private:
    /* @{ */
    std::pmr::vector<DdsSampleSeq> m_samples;
    std::pmr::vector<DdsInfoSeq> m_infos;
    /* @} */
 
    SeqLoanerIf& m_loaner;
};
 
void AgnosticDataSamples::Clear() noexcept {
    for (std::uint8_t idx = 0u; idx < m_samples.size(); ++idx) {
        Clear(idx);
    }
}
void AgnosticDataSamples::Clear(std::uint8_t idx) noexcept {
    assert(idx < Size());
    auto& seq = m_samples[idx];
    if (seq.has_ownership()) {
        // if sequence owns its own memory we simply release the elements
        (void)seq.length(0);
    } else {
        // Otherwise we return the loaned sequence
        (void)m_loaner.ReturnLoan(idx, seq, m_infos[idx]);
    }
}
 
bool AgnosticDataSamples::Empty() const noexcept {
    for (std::uint8_t idx = 0u; idx < Size(); ++idx) {
        if (m_samples[idx].length() > 0) {
            return false;
        }
    }
    return true;
}
 
bool AgnosticDataSamples::Full() const noexcept {
    for (std::uint8_t idx = 0u; idx < Size(); ++idx) {
        if (m_samples[idx].length() == 0) {
            return false;
        }
    }
    return true;
}
 
}  // namespace rtctk::telSub
#endif  // #ifndef RTCTK_TELSUB_AGNOSTICDATASAMPLES_HPP