.. _program_listing_file__tmp_ws_src_fastrtps_include_fastdds_rtps_common_SequenceNumber.h:

Program Listing for File SequenceNumber.h
=========================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_fastrtps_include_fastdds_rtps_common_SequenceNumber.h>` (``/tmp/ws/src/fastrtps/include/fastdds/rtps/common/SequenceNumber.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   // Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
   //
   // Licensed under the Apache License, Version 2.0 (the "License");
   // you may not use this file except in compliance with the License.
   // You may obtain a copy of the License at
   //
   //     http://www.apache.org/licenses/LICENSE-2.0
   //
   // Unless required by applicable law or agreed to in writing, software
   // distributed under the License is distributed on an "AS IS" BASIS,
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   // See the License for the specific language governing permissions and
   // limitations under the License.
   
   #ifndef _FASTDDS_RPTS_ELEM_SEQNUM_H_
   #define _FASTDDS_RPTS_ELEM_SEQNUM_H_
   
   #include <algorithm>
   #include <cassert>
   #include <limits>
   #include <vector>
   
   #include <fastrtps/fastrtps_dll.h>
   #include <fastrtps/utils/fixed_size_bitmap.hpp>
   #include <fastdds/rtps/common/Types.h>
   
   namespace eprosima {
   namespace fastrtps {
   namespace rtps {
   
   
   struct RTPS_DllAPI SequenceNumber_t
   {
       int32_t high = 0;
       uint32_t low = 0;
   
       SequenceNumber_t() noexcept
       {
           high = 0;
           low = 0;
       }
   
       SequenceNumber_t(
               int32_t hi,
               uint32_t lo) noexcept
           : high(hi)
           , low(lo)
       {
       }
   
       explicit
       SequenceNumber_t(
               uint64_t u) noexcept
           : high(static_cast<int32_t>(u >> 32u))
           , low(static_cast<uint32_t>(u))
       {
       }
   
       uint64_t to64long() const noexcept
       {
           return (static_cast<uint64_t>(high) << 32u) + low;
       }
   
       SequenceNumber_t& operator ++() noexcept
       {
           ++low;
           if (low == 0)
           {
               assert(std::numeric_limits<decltype(high)>::max() > high);
               ++high;
           }
   
           return *this;
       }
   
       SequenceNumber_t operator ++(
               int) noexcept
       {
           SequenceNumber_t result(*this);
           ++(*this);
           return result;
       }
   
       SequenceNumber_t& operator +=(
               int inc) noexcept
       {
           assert(inc >= 0);
           uint32_t aux_low = low;
           low +=  static_cast<uint32_t>(inc);
   
           if (low < aux_low)
           {
               // Being the type of the parameter an 'int', the increment of 'high' will be as much as 1.
               assert(std::numeric_limits<decltype(high)>::max() > high);
               ++high;
           }
   
           return *this;
       }
   
       static SequenceNumber_t unknown() noexcept
       {
           return { -1, 0 };
       }
   
   };
   
   #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
   
   inline bool operator ==(
           const SequenceNumber_t& sn1,
           const SequenceNumber_t& sn2) noexcept
   {
       return (sn1.low == sn2.low) && (sn1.high == sn2.high);
   }
   
   inline bool operator !=(
           const SequenceNumber_t& sn1,
           const SequenceNumber_t& sn2) noexcept
   {
       return (sn1.low != sn2.low) || (sn1.high != sn2.high);
   }
   
   inline bool operator >(
           const SequenceNumber_t& seq1,
           const SequenceNumber_t& seq2) noexcept
   {
       if (seq1.high == seq2.high)
       {
           return seq1.low > seq2.low;
       }
   
       return seq1.high > seq2.high;
   }
   
   inline bool operator <(
           const SequenceNumber_t& seq1,
           const SequenceNumber_t& seq2) noexcept
   {
       if (seq1.high == seq2.high)
       {
           return seq1.low < seq2.low;
       }
   
       return seq1.high < seq2.high;
   }
   
   inline bool operator >=(
           const SequenceNumber_t& seq1,
           const SequenceNumber_t& seq2) noexcept
   {
       if (seq1.high == seq2.high)
       {
           return seq1.low >= seq2.low;
       }
   
       return seq1.high > seq2.high;
   }
   
   inline bool operator <=(
           const SequenceNumber_t& seq1,
           const SequenceNumber_t& seq2) noexcept
   {
       if (seq1.high == seq2.high)
       {
           return seq1.low <= seq2.low;
       }
   
       return seq1.high < seq2.high;
   }
   
   inline SequenceNumber_t operator -(
           const SequenceNumber_t& seq,
           const uint32_t inc) noexcept
   {
       SequenceNumber_t res(seq.high, seq.low - inc);
   
       if (inc > seq.low)
       {
           // Being the type of the parameter an 'uint32_t', the decrement of 'high' will be as much as 1.
           assert(0 < res.high);
           --res.high;
       }
   
       return res;
   }
   
   inline SequenceNumber_t operator +(
           const SequenceNumber_t& seq,
           const uint32_t inc) noexcept
   {
       SequenceNumber_t res(seq.high, seq.low + inc);
   
       if (res.low < seq.low)
       {
           // Being the type of the parameter an 'uint32_t', the increment of 'high' will be as much as 1.
           assert(std::numeric_limits<decltype(res.high)>::max() > res.high);
           ++res.high;
       }
   
       return res;
   }
   
   inline SequenceNumber_t operator -(
           const SequenceNumber_t& minuend,
           const SequenceNumber_t& subtrahend) noexcept
   {
       assert(minuend >= subtrahend);
       SequenceNumber_t res(minuend.high - subtrahend.high, minuend.low - subtrahend.low);
   
       if (minuend.low < subtrahend.low)
       {
           assert(0 < res.high);
           --res.high;
       }
   
       return res;
   }
   
   #endif // ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
   
   const SequenceNumber_t c_SequenceNumber_Unknown{-1, 0};
   
   #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
   
   inline bool sort_seqNum(
           const SequenceNumber_t& s1,
           const SequenceNumber_t& s2) noexcept
   {
       return s1 < s2;
   }
   
   inline std::ostream& operator <<(
           std::ostream& output,
           const SequenceNumber_t& seqNum)
   {
       return output << seqNum.to64long();
   }
   
   inline std::ostream& operator <<(
           std::ostream& output,
           const std::vector<SequenceNumber_t>& seqNumSet)
   {
       for (const SequenceNumber_t& sn : seqNumSet)
       {
           output << sn << " ";
       }
   
       return output;
   }
   
   struct SequenceNumberHash
   {
       std::size_t operator ()(
               const SequenceNumber_t& sequence_number) const noexcept
       {
           return static_cast<std::size_t>(sequence_number.to64long());
       }
   
   };
   
   struct SequenceNumberDiff
   {
       uint32_t operator ()(
               const SequenceNumber_t& a,
               const SequenceNumber_t& b) const noexcept
       {
           SequenceNumber_t diff = a - b;
           return diff.low;
       }
   
   };
   
   #endif // ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
   
   using SequenceNumberSet_t = BitmapRange<SequenceNumber_t, SequenceNumberDiff, 256>;
   
   #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
   
   inline std::ostream& operator <<(
           std::ostream& output,
           const SequenceNumberSet_t& sns)
   {
       output << sns.base().to64long() << ":";
       sns.for_each([&output](
                   SequenceNumber_t it)
               {
                   output << it.to64long() << "-";
               });
   
       return output;
   }
   
   inline std::istream& operator >>(
           std::istream& input,
           SequenceNumber_t& seqNum)
   {
       uint64_t aux;
   
       if (input >> aux)
       {
           seqNum = SequenceNumber_t(aux);
       }
   
       return input;
   }
   
   #endif // DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
   
   } // namespace rtps
   } // namespace fastrtps
   } // namespace eprosima
   
   #endif /* _FASTDDS_RTPS_ELEM_SEQNUM_H_ */