Adds immediate migration results

qt6-after/qt6-migrated-legatus/include/rti/routing/processor/SampleIterator.hpp

@@ -0,0 +1,275 @@
+/* $Id$
+
+(c) Copyright, Real-Time Innovations, 2014-2016.
+All rights reserved.
+
+No duplications, whole or partial, manual or electronic, may be made
+without express written permission.  Any such copies, or
+revisions thereof, must display this notice unaltered.
+This code contains trade secrets of Real-Time Innovations, Inc.
+
+
+modification history
+--------------------
+1.0a,05may14,acr Added ValidSampleIterator and valid_samples helper
+1.0a,20mar13,acr Created
+============================================================================= */
+
+#ifndef RTI_ROUTING_PROCESSOR_SAMPLE_ITERATOR_HPP_
+    #define RTI_ROUTING_PROCESSOR_SAMPLE_ITERATOR_HPP_
+
+
+    #include <rti/routing/processor/LoanedSample.hpp>
+    #include <exception>
+
+namespace rti {
+namespace routing {
+namespace processor {
+
+/*i
+ * @brief Tag type to emulate/indicate that sample infos are not available
+ */
+struct no_sample_info_t {
+};
+
+/**
+ * @ingroup RTI_RoutingServiceProcessorModule
+ *
+ * @class rti::routing::processor::SampleIterator
+ * @brief A random-access iterator of LoanedSample
+ *
+ * @see rti::routing::processor::LoanedSamples
+ */
+template <typename T, typename U>
+class SampleIterator {
+public:
+    // iterator traits
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = const LoanedSample<T, U>;
+    using reference = value_type;
+    using pointer = value_type;
+    using difference_type = std::size_t;
+    using SampleSeqType = RTI_RoutingServiceSample*;
+    using InfoSeqType = RTI_RoutingServiceSampleInfo*;
+
+private:
+    static no_sample_info_t *_null_info_scrachtpad[1];
+    static InfoSeqType _null_info_seq;
+    static difference_type _null_info_pos;
+
+public:
+    SampleIterator()
+    : _sample_seq(0),
+    _info_seq(0),
+    _length(0),
+    _pos(0),
+    _info_pos(_pos)
+    {
+    }
+
+    SampleIterator(
+            const SampleSeqType sample_seq,
+            const InfoSeqType info_seq,
+            int length,
+            int position = 0)
+    : _sample_seq(sample_seq),
+    _info_seq(info_seq == NULL ? _null_info_seq : info_seq),
+    _length(length),
+    _info_pos(info_seq == NULL ? _null_info_pos : _pos)
+    {
+        if (position < 0) {
+            throw dds::core::IllegalOperationError("SampleIterator out of range");
+        }
+
+        _pos = static_cast<difference_type>(position);
+    }
+
+    SampleIterator(const SampleIterator<T, U> & other)
+    : _sample_seq(other._sample_seq),
+    _info_seq(other._info_seq),
+    _length(other._length),
+    _pos(other._pos),
+    _info_pos(other._info_pos)
+    {
+    }
+
+    SampleIterator & operator=(const SampleIterator<T, U> & other)
+    {
+        _sample_seq = other._sample_seq;
+        _info_seq = other._info_seq;
+        _length = other._length;
+        _pos = other._pos;
+        _info_pos = other._info_pos;
+
+        return *this;
+    }
+
+    value_type operator*() const
+    {
+        return value_type(_sample_seq[_pos], _info_seq[_info_pos]);
+    }
+
+    value_type operator->() const
+    {
+        return value_type(_sample_seq[_pos], _info_seq[_info_pos]);
+    }
+
+    value_type operator[](difference_type offset) const
+    {
+        return (_info_seq == _null_info_seq)
+                ? value_type(_sample_seq[_pos], NULL)
+                : value_type(_sample_seq[_pos + offset], _info_seq[_info_pos + offset]);
+    }
+
+/*
+ * Windows defines min and max in one of the Windows headers, and they
+ * collide with the max() definition we use below
+ */
+#ifdef RTI_WIN32
+#undef max
+#undef min
+#endif
+    SampleIterator & operator++()
+    {
+        if (_pos == std::numeric_limits<difference_type>::max()) {
+            throw dds::core::IllegalOperationError("SampleIterator out of range");
+        }
+
+        ++_pos;
+        return *this;
+    }
+
+    SampleIterator operator++(int)
+    {
+        SampleIterator temp(*this);
+        ++(*this);
+        return temp;
+    }
+
+    SampleIterator & operator--()
+    {
+        if (_pos == std::numeric_limits<difference_type>::min()) {
+            throw dds::core::IllegalOperationError("SampleIterator out of range");
+        }
+
+        --_pos;
+        return *this;
+    }
+
+    SampleIterator operator--(int)
+    {
+        SampleIterator temp(*this);
+        --(*this);
+        return temp;
+    }
+
+    SampleIterator & operator-=(difference_type i)
+    {
+        if (i > _pos) {
+            throw dds::core::IllegalOperationError("SampleIterator out of range");
+        }
+
+        _pos -= i;
+        return *this;
+    }
+
+    SampleIterator & operator+=(difference_type i)
+    {
+        if ((std::numeric_limits<difference_type>::max() - _pos) < i) {
+            throw dds::core::IllegalOperationError("SampleIterator out of range");
+        }
+
+        _pos += i;
+        return *this;
+    }
+
+    friend SampleIterator operator-(
+            const SampleIterator& si,
+            difference_type i)
+    {
+        SampleIterator temp(si);
+        temp -= i;
+        return temp;
+    }
+
+    friend SampleIterator operator+(
+            const SampleIterator& si,
+            difference_type i)
+    {
+        SampleIterator temp(si);
+        temp += i;
+        return temp;
+    }
+
+    friend difference_type operator-(
+            const SampleIterator& s1,
+            const SampleIterator& s2)
+    {
+        return s1._pos - s2._pos;
+    }
+
+    friend bool operator<(const SampleIterator & s1,
+            const SampleIterator & s2)
+    {
+        return s1._pos < s2._pos;
+    }
+
+    friend bool operator>(const SampleIterator & s1,
+            const SampleIterator & s2)
+    {
+        return s1._pos > s2._pos;
+    }
+
+    friend bool operator<=(const SampleIterator & s1,
+            const SampleIterator & s2)
+    {
+        return s1._pos <= s2._pos;
+    }
+
+    friend bool operator>=(const SampleIterator & s1,
+            const SampleIterator & s2)
+    {
+        return s1._pos >= s2._pos;
+    }
+
+    friend bool operator==(const SampleIterator & s1,
+            const SampleIterator & s2)
+    {
+        return (s1._sample_seq == s2._sample_seq) && (s1._pos == s2._pos);
+    }
+
+    friend bool operator!=(const SampleIterator & s1,
+            const SampleIterator & s2)
+    {
+        return !(s1 == s2);
+    }
+
+    bool is_end() const
+    {
+        return (_length == _pos);
+    }
+
+    // Keep these members public otherwise some of the
+    // converting constructors will not compile.
+public:
+    SampleSeqType _sample_seq;
+    InfoSeqType _info_seq;
+    int _length;
+    difference_type _pos;
+    difference_type& _info_pos;
+};
+
+
+template <typename T, typename U>
+std::size_t SampleIterator<T, U>::_null_info_pos = 0;
+
+template <typename T, typename U>
+no_sample_info_t * SampleIterator<T, U>::_null_info_scrachtpad[1] = {NULL};
+
+template <typename T, typename U>
+typename SampleIterator<T, U>::InfoSeqType SampleIterator<T, U>::_null_info_seq =
+reinterpret_cast<InfoSeqType> (SampleIterator<T, U>::_null_info_scrachtpad);
+
+} } }
+
+#endif // RTI_ROUTING_PROCESSOR_SAMPLE_ITERATOR_HPP_