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 <string>
#include <system_error>
#include <unordered_map>
#include <vector>
 
#include <rtctk/componentFramework/dds.hpp>
 
namespace rtctk::telSub {
 
// Alias of the DDS topic type used throughout telSub
using DdsSample = rtctk::componentFramework::AgnosticTopic;
using DdsSampleSeq = rtctk::componentFramework::AgnosticTopicSeq;
 
using DdsInfoSeq = rtctk::componentFramework::SampleInfoSeq;
 
class SeqLoanerIf {
public:
    virtual std::error_code ReturnLoan(const std::string& topic,
                                       DdsSampleSeq& samples,
                                       DdsInfoSeq& infos) RTCTK_NOEXCEPT = 0;
};
 
class AgnosticDataSamples {
private:
    const size_t m_expected_topic_count;
    std::pmr::map<std::string, std::pair<DdsSampleSeq, DdsInfoSeq>> m_samples;
    SeqLoanerIf& m_loaner;
 
public:
    using Alloc = std::pmr::polymorphic_allocator<std::byte>;
 
    AgnosticDataSamples(SeqLoanerIf& loaner, size_t topic_count, const Alloc& alloc = {})
        : m_expected_topic_count(topic_count), m_samples(alloc), m_loaner(loaner) {
    }
    ~AgnosticDataSamples() noexcept {
        Clear();
    }
 
    AgnosticDataSamples(const AgnosticDataSamples&) = delete;
    AgnosticDataSamples& operator=(const AgnosticDataSamples&) = delete;
 
 
    inline std::uint8_t Size() const noexcept {
        return m_samples.size();
    }
 
    inline DdsSampleSeq& operator[](const std::string& topic) noexcept {
        return m_samples[topic].first;
    }
 
    inline const DdsSampleSeq& At(const std::string& topic) const {
        return m_samples.at(topic).first;
    }
 
    inline bool Empty() const noexcept;
 
    inline bool Full() const noexcept;
 
 
    inline std::tuple<DdsSampleSeq&, DdsInfoSeq&> GetUpdateRefs(const std::string& topic) noexcept {
        return {m_samples[topic].first, m_samples[topic].second};
    }
 
    inline void Clear(const std::string& topic) noexcept;
 
    inline void Clear() noexcept;
 
    using iterator = decltype(m_samples)::iterator;
    using const_iterator = decltype(m_samples)::const_iterator;
 
    iterator begin() {  // NOLINT(readability-identifier-naming)
        return m_samples.begin();
    };
 
    const_iterator cbegin() {  // NOLINT(readability-identifier-naming)
        return m_samples.cbegin();
    };
 
    iterator end() {  // NOLINT(readability-identifier-naming)
        return m_samples.end();
    };
 
    const_iterator cend() {  // NOLINT(readability-identifier-naming)
        return m_samples.cend();
    };
 
};
 
void AgnosticDataSamples::Clear() noexcept {
    for (const auto& entry : m_samples) {
        Clear(entry.first);
    }
    assert(Empty());
}
void AgnosticDataSamples::Clear(const std::string& topic) noexcept {
    auto& seq = m_samples.at(topic).first;
    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(topic, seq, m_samples[topic].second);
    }
    assert(not Full());
}
 
bool AgnosticDataSamples::Empty() const noexcept {
    for (const auto& [topic, sample] : m_samples) {
        if (sample.first.length() > 0) {
            return false;
        }
    }
    return true;
}
 
bool AgnosticDataSamples::Full() const noexcept {
    if (m_samples.size() != m_expected_topic_count) {
        return false;
    }
    for (const auto& [topic, sample] : m_samples) {
        if (sample.first.length() == 0) {
            return false;
        }
    }
    return true;
}
 
}  // namespace rtctk::telSub
 
#endif  // RTCTK_TELSUB_AGNOSTICDATASAMPLES_HPP