#include <DisjointSequence.h>

Collaboration diagram for OpenDDS::DCPS::DisjointSequence:

Classes
class	OrderedRanges

Public Member Functions
	DisjointSequence ()

void	reset ()

bool	empty () const

SequenceNumber	low () const

SequenceNumber	high () const

SequenceNumber	cumulative_ack () const

SequenceNumber	last_ack () const

bool	disjoint () const

bool	contains (SequenceNumber value) const

bool	contains_any (const SequenceRange &range) const

bool	insert (const SequenceRange &range, OPENDDS_VECTOR(SequenceRange)&added)

bool	insert (const SequenceRange &range)
	Insert all numbers between range.first and range.second (both inclusive). More...

bool	insert (SequenceNumber value)
	Shorthand for "insert(SequenceRange(value, value))". More...

void	erase (SequenceNumber value)

bool	insert (SequenceNumber value, ACE_CDR::ULong num_bits, const ACE_CDR::Long bits[])

bool	insert_filtered (const SequenceRange &range, const DisjointSequence &filter)
	Insert the intersection of range and filter. More...

bool	to_bitmap (ACE_CDR::Long bitmap[], ACE_CDR::ULong length, ACE_CDR::ULong &num_bits, ACE_CDR::ULong &cumulative_bits_added, bool invert=false) const

	OPENDDS_VECTOR (SequenceRange) missing_sequence_ranges() const
	Returns missing ranges of SequenceNumbers (internal gaps in the sequence) More...

	OPENDDS_VECTOR (SequenceRange) present_sequence_ranges() const

void	dump () const

Static Public Member Functions
static bool	fill_bitmap_range (ACE_CDR::ULong low, ACE_CDR::ULong high, ACE_CDR::Long bitmap[], ACE_CDR::ULong length, ACE_CDR::ULong &num_bits, ACE_CDR::ULong &cumulative_bits_added)
	Set the bits in range [low, high] in the bitmap, updating num_bits. More...

static ACE_CDR::ULong	bitmap_num_longs (const SequenceNumber &low, const SequenceNumber &high)

Private Types
typedef OrderedRanges< SequenceNumber >	RangeSet

Private Member Functions
bool	insert_i (const SequenceRange &range, OPENDDS_VECTOR(SequenceRange) *gaps=0)

bool	insert_bitmap_range (RangeSet::Container::iterator &iter, const SequenceRange &sr)

Private Attributes
RangeSet	sequences_

Detailed Description

Data structure for a set of SequenceNumbers. Sequence numbers can be inserted as single numbers, ranges, or RTPS-style bitmaps. The DisjointSequence can then be queried for contiguous ranges and internal gaps.

Definition at line 23 of file DisjointSequence.h.

Member Typedef Documentation

◆ RangeSet

typedef OrderedRanges<SequenceNumber> OpenDDS::DCPS::DisjointSequence::RangeSet

private

Definition at line 274 of file DisjointSequence.h.

Constructor & Destructor Documentation

◆ DisjointSequence()

ACE_INLINE OpenDDS::DCPS::DisjointSequence::DisjointSequence ( )

Definition at line 54 of file DisjointSequence.inl.

References ACE_INLINE.

55 {

56 }

Member Function Documentation

◆ bitmap_num_longs()

ACE_CDR::ULong OpenDDS::DCPS::DisjointSequence::bitmap_num_longs	(	const SequenceNumber &	low,
		const SequenceNumber &	high
	)

static

Return the number of CORBA::Longs required for the bitmap representation of sequence numbers between low and high, inclusive (maximum 8 longs).

Definition at line 331 of file DisjointSequence.cpp.

References OpenDDS::DCPS::SequenceNumber::getValue().

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::gather_ack_nacks_i(), and OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::gather_gaps_i().

 {
   return high < low ? 0u : std::min(8u, unsigned((high.getValue() - low.getValue() + 32) / 32));
 }

◆ contains()

bool OpenDDS::DCPS::DisjointSequence::contains ( SequenceNumber value ) const

Referenced by insert_filtered(), and OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::process_gap_i().

◆ contains_any()

bool OpenDDS::DCPS::DisjointSequence::contains_any ( const SequenceRange & range ) const

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::include_fragment(), and insert_filtered().

◆ cumulative_ack()

ACE_INLINE SequenceNumber OpenDDS::DCPS::DisjointSequence::cumulative_ack ( ) const

Gets the high end of the lowest contiguous range. Named after the use case of tracking received messages (which may be received out-of-order) and then determining the largest value that the receiver is allowed to acknowledge (under a cumulative-acking protocol). If empty(), returns SEQUENCENUMBER_UNKNOWN.

Definition at line 26 of file DisjointSequence.inl.

References ACE_INLINE, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::begin(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::empty(), OpenDDS::DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN(), and sequences_.

Referenced by OpenDDS::DCPS::ReliableSession::deliver_held_data(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::gather_ack_nacks_i(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::gather_gaps_i(), OpenDDS::DCPS::ReliableSession::ready_to_deliver(), OpenDDS::DCPS::ReliableSession::send_naks(), and to_bitmap().

 {
   return sequences_.empty()
     ? SequenceNumber::SEQUENCENUMBER_UNKNOWN()
     : sequences_.begin()->second;
 }

◆ disjoint()

ACE_INLINE bool OpenDDS::DCPS::DisjointSequence::disjoint ( ) const

Objects with the disjoint() property have an internal gap in the inserted SequenceNumbers.

Definition at line 48 of file DisjointSequence.inl.

References ACE_INLINE, sequences_, and OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::size().

Referenced by fill_bitmap_range(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::gather_ack_nacks_i(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::gather_gaps_i(), OpenDDS::DCPS::ReliableSession::ready_to_deliver(), OpenDDS::DCPS::ReliableSession::send_naks(), and to_bitmap().

 {
   return sequences_.size() > 1;
 }

◆ dump()

void OpenDDS::DCPS::DisjointSequence::dump ( void ) const

Definition at line 319 of file DisjointSequence.cpp.

References ACE_DEBUG, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::begin(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::end(), LM_DEBUG, and sequences_.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::gather_nack_replies_i(), and OpenDDS::DCPS::ReliableSession::send_naks().

 {
   ACE_DEBUG((LM_DEBUG, "(%P|%t) DisjointSequence[%X]::dump included ranges of "
                        "SequenceNumbers:\n", this));
   for (RangeSet::const_iterator iter = sequences_.begin();
        iter != sequences_.end(); ++iter) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) DisjointSequence[%X]::dump\t%q-%q\n",
                this, iter->first.getValue(), iter->second.getValue()));
   }
 }

◆ empty()

ACE_INLINE bool OpenDDS::DCPS::DisjointSequence::empty ( void ) const

Definition at line 42 of file DisjointSequence.inl.

References ACE_INLINE, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::empty(), and sequences_.

Referenced by OpenDDS::DCPS::ReliableSession::deliver_held_data(), OpenDDS::DCPS::RtpsUdpDataLink::durability_resend(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::gather_ack_nacks_i(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::gather_gaps_i(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::gather_nack_replies_i(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::process_gap_i(), OpenDDS::DCPS::ReliableSession::ready_to_deliver(), and OpenDDS::DCPS::SingleSendBuffer::resend_fragments_i().

 {
   return sequences_.empty();
 }

◆ erase()

void OpenDDS::DCPS::DisjointSequence::erase ( SequenceNumber value )

Definition at line 337 of file DisjointSequence.cpp.

References OPENDDS_END_VERSIONED_NAMESPACE_DECL, OpenDDS::DCPS::SequenceNumber::previous(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::ranges_, and sequences_.

Referenced by OpenDDS::DCPS::WriteDataContainer::reenqueue_all().

 {
   RangeSet::Container::iterator iter =
     sequences_.ranges_.lower_bound(SequenceRange(0 /*ignored*/, value));
   if (iter != sequences_.ranges_.end()) {
     if (iter->first == value &&
         iter->second == value) {
       sequences_.ranges_.erase(iter);
     } else if (iter->first == value) {
       SequenceRange x(value + 1, iter->second);
       sequences_.ranges_.erase(iter);
       sequences_.ranges_.insert(x);
     } else if (iter->second == value) {
       SequenceRange x(iter->first, value.previous());
       sequences_.ranges_.erase(iter);
       sequences_.ranges_.insert(x);
     } else {
       SequenceRange x(iter->first, value.previous());
       SequenceRange y(value + 1, iter->second);
       sequences_.ranges_.erase(iter);
       sequences_.ranges_.insert(x);
       sequences_.ranges_.insert(y);
     }
   }
 }

◆ fill_bitmap_range()

bool OpenDDS::DCPS::DisjointSequence::fill_bitmap_range	(	ACE_CDR::ULong	low,
		ACE_CDR::ULong	high,
		ACE_CDR::Long	bitmap[],
		ACE_CDR::ULong	length,
		ACE_CDR::ULong &	num_bits,
		ACE_CDR::ULong &	cumulative_bits_added
	)

static

Set the bits in range [low, high] in the bitmap, updating num_bits.

Definition at line 238 of file DisjointSequence.cpp.

References OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::begin(), disjoint(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::end(), OPENDDS_VECTOR(), OpenDDS::DCPS::SequenceNumber::previous(), and sequences_.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::extend_bitmap_range(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::gather_ack_nacks_i(), OpenDDS::DCPS::TransportReassembly::get_gaps(), and to_bitmap().

 {
   bool clamped = false;
   if ((low / 32) >= length) {
     return false;
   }
   if ((high / 32) >= length) {
     high = length * 32 - 1;
     clamped = true;
   }
 
   const ACE_CDR::ULong idx_nb = num_bits / 32, bit_nb = num_bits % 32,
                      idx_low = low / 32, bit_low = low % 32,
                      idx_high = high / 32, bit_high = high % 32;
 
   // handle idx_nb zeros
   if (bit_nb) {
     bitmap[idx_nb] &= ~((0x1u << (32 - bit_nb)) - 1);
   } else {
     bitmap[idx_nb] = 0;
   }
 
   // handle zeros between idx_nb and idx_low (if gap exists)
   for (ACE_CDR::ULong i = idx_nb + 1; i < idx_low; ++i) {
     bitmap[i] = 0;
   }
 
   // handle idx_nb ones
   if (bit_low) {
     if (idx_low > idx_nb) {
       bitmap[idx_low] = (0x1u << (32 - bit_low)) - 1;
     } else {
       bitmap[idx_low] |= (0x1u << (32 - bit_low)) - 1;
     }
   } else {
     bitmap[idx_low] = 0xFFFFFFFF;
   }
 
   // handle ones between idx_low and idx_high (if gap exists)
   for (ACE_CDR::ULong i = idx_low + 1; i < idx_high; ++i) {
     bitmap[i] = 0xFFFFFFFF;
   }
 
   // handle idx_high
   if (idx_high > idx_low) {
     bitmap[idx_high] = ~((0x1u << (31 - bit_high)) - 1);
   } else if (bit_high < 31) {
     bitmap[idx_high] &= ~((0x1u << (31 - bit_high)) - 1);
   }
 
   num_bits = high + 1;
   cumulative_bits_added += high - low + 1;
   return !clamped;
 }

◆ high()

ACE_INLINE SequenceNumber OpenDDS::DCPS::DisjointSequence::high ( ) const

Highest SequenceNumber in the set. Precondition: !empty()

Definition at line 20 of file DisjointSequence.inl.

References ACE_INLINE, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::rbegin(), and sequences_.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::gather_ack_nacks_i(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::gather_gaps_i(), insert_bitmap_range(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::process_gap_i(), and to_bitmap().

 {
   return sequences_.rbegin()->second;
 }

◆ insert() [1/4]

ACE_INLINE bool OpenDDS::DCPS::DisjointSequence::insert	(	const SequenceRange &	range,
		OPENDDS_VECTOR(SequenceRange)&	added
	)

All insert() methods return true upon modifying the set and false if the set already contained the SequenceNumber(s) that were to be inserted. This is the general form of insert() whereby the caller receives a list of sub-ranges of 'range' that were not already in the DisjointSequence. For example, given a DisjointSequence 'seq' containing (1, 2, 5, 9), calling seq.insert(SequenceRange(4, 12), v) returns true and yields v = [(4, 4), (6, 8), (10, 12)] and seq = (1, 2, 4, ..., 12).

Definition at line 77 of file DisjointSequence.inl.

References ACE_INLINE, and insert_i().

 {
   return insert_i(range, &gaps);
 }

◆ insert() [2/4]

ACE_INLINE bool OpenDDS::DCPS::DisjointSequence::insert ( const SequenceRange & range )

Insert all numbers between range.first and range.second (both inclusive).

Definition at line 71 of file DisjointSequence.inl.

References ACE_INLINE, and insert_i().

 {
   return insert_i(range);
 }

◆ insert() [3/4]

ACE_INLINE bool OpenDDS::DCPS::DisjointSequence::insert ( SequenceNumber value )

Shorthand for "insert(SequenceRange(value, value))".

Definition at line 65 of file DisjointSequence.inl.

References ACE_INLINE, and insert_i().

 {
   return insert_i(SequenceRange(value, value));
 }

◆ insert() [4/4]

bool OpenDDS::DCPS::DisjointSequence::insert	(	SequenceNumber	value,
		ACE_CDR::ULong	num_bits,
		const ACE_CDR::Long	bits[]
	)

Insert using the RTPS compact representation of a set. The three parameters, taken together, describe a set with each 1 bit starting at the msb of bits[0] and extending through num_bits (which are located at the next least significant bits of bits[0] followed by the msb of bits[1], etc.) indicating presence of the number (value + bit_index) in the set. bit_index is 0-based. Precondition: the array 'bits' has at least ceil(num_bits / 32) entries.

Definition at line 91 of file DisjointSequence.cpp.

References OpenDDS::DCPS::SequenceNumber::getValue(), insert_bitmap_range(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::ranges_, and sequences_.

 {
   bool inserted = false;
   RangeSet::Container::iterator iter = sequences_.ranges_.end();
   bool range_start_is_valid = false;
   SequenceNumber::Value range_start = 0;
   const SequenceNumber::Value val = value.getValue();
 
   // See RTPS v2.1 section 9.4.2.6 SequenceNumberSet
   for (ACE_CDR::ULong i = 0, x = 0, bit = 0; i < num_bits; ++i, ++bit) {
 
     if (bit == 32) bit = 0;
 
     if (bit == 0) {
       x = static_cast<ACE_CDR::ULong>(bits[i / 32]);
       if (x == 0) {
         // skip an entire Long if it's all 0's (adds 32 due to ++i)
         i += 31;
         bit = 31;
         //FUTURE: this could be generalized with something like the x86 "bsr"
         //        instruction using compiler intrinsics, VC++ _BitScanReverse()
         //        and GCC __builtin_clz()
         continue;
       }
     }
 
     if (x & (1 << (31 - bit))) {
       if (!range_start_is_valid) {
         range_start = val + i;
         range_start_is_valid = true;
       }
     } else if (range_start_is_valid) {
       // this is a "0" bit and we've previously seen a "1": insert a range
       const SequenceNumber::Value to_insert = val + i - 1;
       if (insert_bitmap_range(iter, SequenceRange(range_start, to_insert))) {
         inserted = true;
       }
       range_start = 0;
       range_start_is_valid = false;
 
       if (iter != sequences_.ranges_.end() && iter->second.getValue() != to_insert) {
         // skip ahead: next gap in sequence must be past iter->second
         ACE_CDR::ULong next_i = ACE_CDR::ULong(iter->second.getValue() - val);
         bit = next_i % 32;
         if (next_i / 32 != i / 32 && next_i < num_bits) {
           x = static_cast<ACE_CDR::ULong>(bits[next_i / 32]);
         }
         i = next_i;
       }
     }
   }
 
   if (range_start_is_valid) {
     // iteration finished before we saw a "0" (inside a range)
     SequenceNumber range_end = (value + num_bits).previous();
     if (insert_bitmap_range(iter, SequenceRange(range_start, range_end))) {
       return true;
     }
   }
   return inserted;
 }

◆ insert_bitmap_range()

bool OpenDDS::DCPS::DisjointSequence::insert_bitmap_range	(	RangeSet::Container::iterator &	iter,
		const SequenceRange &	sr
	)

private

Definition at line 155 of file DisjointSequence.cpp.

References OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::empty(), high(), low(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::ranges_, and sequences_.

Referenced by insert().

 {
   // This is similar to insert_i(), except it doesn't need an O(log(n)) search
   // of sequences_ every time to find the starting point, and it doesn't
   // compute the 'gaps'.
 
   const SequenceNumber::Value previous = range.first.getValue() - 1,
     next = range.second.getValue() + 1;
 
   if (!sequences_.empty()) {
     if (iter == sequences_.ranges_.end()) {
       iter = sequences_.ranges_.lower_bound(SequenceRange(0 /*ignored*/, previous));
     } else {
       // start where we left off last time and get the lower_bound(previous)
       for (; iter != sequences_.ranges_.end() && iter->second < previous; ++iter) ;
     }
   }
 
   if (iter == sequences_.ranges_.end() || iter->first > next) {
     // can't combine on either side, insert a new range
     iter = sequences_.ranges_.insert(iter, range);
     return true;
   }
 
   if (iter->first <= range.first && iter->second >= range.second) {
     // range is already covered by this DisjointSet
     return false;
   }
 
   // find the right-most (highest) range we can use
   RangeSet::Container::iterator right = iter;
   for (; right != sequences_.ranges_.end() && right->second < next; ++right) ;
 
   SequenceNumber high = range.second;
   if (right != sequences_.ranges_.end()
       && right->first <= next && right->first > range.first) {
     high = right->second;
     ++right;
   }
 
   const SequenceNumber low = std::min(iter->first, range.first);
   sequences_.ranges_.erase(iter, right);
 
   iter = sequences_.ranges_.insert(SequenceRange(low, high)).first;
   return true;
 }

◆ insert_filtered()

ACE_INLINE bool OpenDDS::DCPS::DisjointSequence::insert_filtered	(	const SequenceRange &	range,
		const DisjointSequence &	filter
	)

Insert the intersection of range and filter.

Definition at line 84 of file DisjointSequence.inl.

References ACE_INLINE, OpenDDS::DCPS::back_inserter(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::begin(), contains(), contains_any(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::end(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::has(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::has_any(), insert(), OPENDDS_END_VERSIONED_NAMESPACE_DECL, OPENDDS_VECTOR(), sequences_, and value.

 {
   for (SequenceNumber i = range.first; i <= range.second; ++i) {
     if (filter.contains(i) && !insert(i)) {
       return false;
     }
   }
   return true;
 }

◆ insert_i()

bool OpenDDS::DCPS::DisjointSequence::insert_i	(	const SequenceRange &	range,
		OPENDDS_VECTOR(SequenceRange) *	gaps = `0`
	)

private

Definition at line 28 of file DisjointSequence.cpp.

References OPENDDS_ASSERT, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::ranges_, sequences_, and OpenDDS::DCPS::SequenceNumber::ZERO().

Referenced by insert().

 {
   OPENDDS_ASSERT(range.first <= range.second);
 
   typedef RangeSet::Container::iterator iter_t;
 
   iter_t range_above = sequences_.ranges_.lower_bound(range);
   if (range_above != sequences_.ranges_.end()
       && range_above->first <= range.first) {
     return false; // already have this range, nothing to insert
   }
 
   SequenceRange newRange = range;
   if (range_above != sequences_.ranges_.end()
       && ++SequenceNumber(newRange.second) >= range_above->first) {
     // newRange overlaps range_above, replace range_above with modified newRange
     newRange.second = range_above->second;
     // move to just past this iterator for the erase
     ++range_above;
   }
 
   const SequenceNumber::Value previous = range.first.getValue() - 1;
   // find the lower_bound for the SequenceNumber just before this range
   // to see if any ranges need to combine
   const iter_t range_below =
     sequences_.ranges_.lower_bound(SequenceRange(1 /*ignored*/,
                                                  (previous > 0) ? previous
                                                  : SequenceNumber::ZERO()));
   if (range_below != sequences_.ranges_.end()) {
     // if low end falls inside of the range_below range
     // then combine
     if (newRange.first > range_below->first) {
       newRange.first = range_below->first;
     }
 
     if (gaps) {
       iter_t gap_iter = range_below;
       if (range.first < gap_iter->second) {
         gaps->push_back(SequenceRange(range.first,
                                       gap_iter->second.previous()));
       }
       SequenceNumber last_gap = gap_iter++->second;
       for (; gap_iter != range_above; ++gap_iter) {
         const SequenceNumber in_range =
           std::min(gap_iter->first.previous().getValue(),
                    range.second.getValue());
         gaps->push_back(SequenceRange(++last_gap, in_range));
         last_gap = gap_iter->second;
       }
       if (last_gap < range.second) {
         gaps->push_back(SequenceRange(++last_gap, range.second));
       }
     }
 
     sequences_.ranges_.erase(range_below, range_above);
   }
 
   sequences_.ranges_.insert(newRange);
   return true;
 }

◆ last_ack()

ACE_INLINE SequenceNumber OpenDDS::DCPS::DisjointSequence::last_ack ( ) const

Gets the low end of the highest contiguous range, may be thought of as the inverse of cumulative_ack(). If empty(), returns SEQUENCENUMBER_UNKNOWN.

Definition at line 34 of file DisjointSequence.inl.

References ACE_INLINE, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::empty(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::rbegin(), OpenDDS::DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN(), and sequences_.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::gather_ack_nacks_i().

 {
   return sequences_.empty()
     ? SequenceNumber::SEQUENCENUMBER_UNKNOWN()
     : sequences_.rbegin()->first;
 }

◆ low()

ACE_INLINE SequenceNumber OpenDDS::DCPS::DisjointSequence::low ( ) const

Lowest SequenceNumber in the set. Precondition: !empty()

Definition at line 14 of file DisjointSequence.inl.

References ACE_INLINE, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::begin(), and sequences_.

Referenced by OpenDDS::DCPS::ReliableSession::deliver_held_data(), OpenDDS::DCPS::ReliableSession::expire_naks(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::gather_gaps_i(), insert_bitmap_range(), OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::process_gap_i(), OpenDDS::DCPS::ReliableSession::ready_to_deliver(), OpenDDS::DCPS::ReliableSession::send_naks(), and to_bitmap().

 {
   return sequences_.begin()->first;
 }

◆ OPENDDS_VECTOR() [1/2]

OpenDDS::DCPS::DisjointSequence::OPENDDS_VECTOR ( SequenceRange ) const

Returns missing ranges of SequenceNumbers (internal gaps in the sequence)

Referenced by fill_bitmap_range(), and insert_filtered().

◆ OPENDDS_VECTOR() [2/2]

OpenDDS::DCPS::DisjointSequence::OPENDDS_VECTOR ( SequenceRange ) const

Returns a representation of the members of the sequence as a list of contiguous ranges (each Range is inclusive on both sides).

◆ reset()

ACE_INLINE void OpenDDS::DCPS::DisjointSequence::reset ( void )

Definition at line 59 of file DisjointSequence.inl.

References ACE_INLINE, OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::clear(), and sequences_.

Referenced by OpenDDS::DCPS::WriteDataContainer::add_reader_acks(), and OpenDDS::DCPS::ReliableSession::syn_hook().

 {
   sequences_.clear();
 }

◆ to_bitmap()

bool OpenDDS::DCPS::DisjointSequence::to_bitmap	(	ACE_CDR::Long	bitmap[],
		ACE_CDR::ULong	length,
		ACE_CDR::ULong &	num_bits,
		ACE_CDR::ULong &	cumulative_bits_added,
		bool	invert = `false`
	)		const

Inverse of insert(value, num_bits, bits). Populates array of bitmap[length] with the bitmap of ranges above the cumulative_ack() value. Sets the number of significant (used) bits in num_bits. The 'base' of the bitmap is one larger than cumulative_ack(). Returns true if the entire DisjointSequence was able to fit in bitmap[]. Returning false is not an error, it's just that the higher-valued ranges didn't fit. If invert is true, the 1's in the bitmap represent the missing_sequence_ranges() instead of the present_sequence_ranges(). Precondition: the array 'bits' has 'length' entries allocated.

Definition at line 204 of file DisjointSequence.cpp.

References OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::begin(), cumulative_ack(), disjoint(), OpenDDS::DCPS::DisjointSequence::OrderedRanges< T >::end(), fill_bitmap_range(), OpenDDS::DCPS::SequenceNumber::getValue(), high(), low(), and sequences_.

Referenced by OpenDDS::DCPS::RtpsUdpDataLink::RtpsReader::gather_ack_nacks_i(), and OpenDDS::DCPS::RtpsUdpDataLink::RtpsWriter::gather_gaps_i().

 {
   // num_bits will be 1 more than the index of the last bit we wrote
   num_bits = 0;
   if (!disjoint()) {
     return true;
   }
 
   const SequenceNumber base = ++SequenceNumber(cumulative_ack());
 
   for (RangeSet::const_iterator iter = sequences_.begin(), prev = iter++;
        iter != sequences_.end(); ++iter, ++prev) {
 
     ACE_CDR::ULong low = 0, high = 0;
 
     if (invert) {
       low = ACE_CDR::ULong(prev->second.getValue() + 1 - base.getValue());
       high = ACE_CDR::ULong(iter->first.getValue() - 1 - base.getValue());
 
     } else {
       low = ACE_CDR::ULong(iter->first.getValue() - base.getValue());
       high = ACE_CDR::ULong(iter->second.getValue() - base.getValue());
     }
 
     if (!fill_bitmap_range(low, high, bitmap, length, num_bits, cumulative_bits_added)) {
       return false;
     }
   }
 
   return true;
 }

Member Data Documentation

◆ sequences_

RangeSet OpenDDS::DCPS::DisjointSequence::sequences_

private

Definition at line 275 of file DisjointSequence.h.

Referenced by cumulative_ack(), disjoint(), dump(), empty(), erase(), fill_bitmap_range(), high(), insert(), insert_bitmap_range(), insert_filtered(), insert_i(), last_ack(), low(), reset(), and to_bitmap().

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ RangeSet

Constructor & Destructor Documentation

◆ DisjointSequence()

Member Function Documentation

◆ bitmap_num_longs()

◆ contains()

◆ contains_any()

◆ cumulative_ack()

◆ disjoint()

◆ dump()

◆ empty()

◆ erase()

◆ fill_bitmap_range()

◆ high()

◆ insert() [1/4]

◆ insert() [2/4]

◆ insert() [3/4]

◆ insert() [4/4]

◆ insert_bitmap_range()

◆ insert_filtered()

◆ insert_i()

◆ last_ack()

◆ low()

◆ OPENDDS_VECTOR() [1/2]

◆ OPENDDS_VECTOR() [2/2]

◆ reset()

◆ to_bitmap()

Member Data Documentation

◆ sequences_