Iterator over only members of a TrackList of the specified subtype, optionally filtered by a predicate; past-end value dereferenceable, to nullptr. More...

#include <Track.h>

Inheritance diagram for TrackIter< TrackType >:

[legend]

Collaboration diagram for TrackIter< TrackType >:

[legend]

Public Types
using	FunctionType = std::function< bool(std::add_pointer_t< std::add_const_t< std::remove_pointer_t< TrackType > > >) >
	Type of predicate taking pointer to const TrackType. More...

Public Types inherited from ValueIterator< TrackType *, std::bidirectional_iterator_tag >
using	iterator_category = std::bidirectional_iterator_tag

using	value_type = TrackType *

using	difference_type = ptrdiff_t

using	pointer = void

using	reference = const TrackType *

Public Member Functions
	TrackIter (TrackNodePointer begin, TrackNodePointer iter, TrackNodePointer end, FunctionType pred={})
	Constructor, usually not called directly except by methods of TrackList. More...

template<typename Predicate2 >
TrackIter	Filter (const Predicate2 &pred2) const
	Return an iterator that replaces the predicate. More...

template<typename TrackType2 >
auto	Filter () const -> std::enable_if_t< std::is_base_of_v< TrackType, TrackType2 > &&(!std::is_const_v< TrackType >\|\|std::is_const_v< TrackType2 >), TrackIter< TrackType2 > >
	Return an iterator for a subclass of TrackType (and not removing const) with same predicate. More...

const FunctionType &	GetPredicate () const

TrackIter &	operator++ ()
	Safe to call even when at the end. More...

TrackIter	operator++ (int)
	Safe to call even when at the end. More...

TrackIter &	operator-- ()
	Safe to call even when at the beginning. More...

TrackIter	operator-- (int)
	Safe to call even when at the beginning. More...

TrackType *	operator* () const
	Safe to call even when at the end. More...

TrackIter	advance (long amount) const
	This might be called operator + , but it's not constant-time as with a random access iterator. More...

Private Member Functions
bool	valid () const
	Test satisfaction of the invariant, while initializing, incrementing, or decrementing. More...

Private Attributes
friend	TrackIterRange< TrackType >
	This friendship is needed in TrackIterRange::StartingWith and TrackIterRange::EndingAfter() More...

TrackNodePointer	mBegin
	Allows end of reverse iteration to be detected without comparison to other TrackIter. More...

TrackNodePointer	mIter
	Current position. More...

TrackNodePointer	mEnd
	Allows end of iteration to be detected without comparison to other TrackIter. More...

FunctionType	mPred
	Optional filter More...

Friends
bool	operator== (TrackIter a, TrackIter b)
	Compares only current positions, assuming same beginnings and ends. More...

bool	operator!= (TrackIter a, TrackIter b)
	Compares only current positions, assuming same beginnings and ends. More...

Detailed Description

template<typename TrackType>
class TrackIter< TrackType >

Iterator over only members of a TrackList of the specified subtype, optionally filtered by a predicate; past-end value dereferenceable, to nullptr.

Does not suffer invalidation when an underlying std::list iterator is deleted, provided that is not equal to its current position or to the beginning or end iterator.

The filtering predicate is tested only when the iterator is constructed or advanced.

Template Parameters

TrackType Track or a subclass, maybe const-qualified

Definition at line 519 of file Track.h.

Member Typedef Documentation

◆ FunctionType

template<typename TrackType >

using TrackIter< TrackType >::FunctionType = std::function< bool( std::add_pointer_t< std::add_const_t< std::remove_pointer_t<TrackType> > > ) >

Type of predicate taking pointer to const TrackType.

Definition at line 524 of file Track.h.

Constructor & Destructor Documentation

◆ TrackIter()

template<typename TrackType >

TrackIter< TrackType >::TrackIter	(	TrackNodePointer	begin,
		TrackNodePointer	iter,
		TrackNodePointer	end,
		FunctionType	pred = `{}`
	)

inline

Constructor, usually not called directly except by methods of TrackList.

Parameters

begin	Remember lower bound
iter	The actual pointer
end	Remember upper bound
pred	Optional filter

Definition at line 529 of file Track.h.

                             {} 
   )
      : mBegin( begin ), mIter( iter ), mEnd( end )
      , mPred( std::move(pred) )
   {
      // Establish the class invariant
      if (this->mIter != this->mEnd && !this->valid())
         this->operator ++ ();
   }

Member Function Documentation

◆ advance()

template<typename TrackType >

TrackIter TrackIter< TrackType >::advance ( long amount ) const

inline

This might be called operator + , but it's not constant-time as with a random access iterator.

Parameters

amount may be negative

Definition at line 626 of file Track.h.

   {
      auto copy = *this;
      std::advance( copy, amount );
      return copy;
   }

References staffpad::vo::copy().

Here is the call graph for this function:

◆ Filter() [1/2]

template<typename TrackType >

template<typename TrackType2 >

auto TrackIter< TrackType >::Filter ( ) const -> std::enable_if_t< std::is_base_of_v< TrackType, TrackType2 > && (!std::is_const_v<TrackType> || std::is_const_v<TrackType2>), TrackIter< TrackType2 > >

inline

Return an iterator for a subclass of TrackType (and not removing const) with same predicate.

Advance to the first position at or after the old position that satisfies the type constraint, or to the end

Definition at line 556 of file Track.h.

   {
      return { this->mBegin, this->mIter, this->mEnd, this->mPred };
   }

References TrackIter< TrackType >::mBegin, TrackIter< TrackType >::mEnd, TrackIter< TrackType >::mIter, and TrackIter< TrackType >::mPred.

◆ Filter() [2/2]

template<typename TrackType >

template<typename Predicate2 >

TrackIter TrackIter< TrackType >::Filter ( const Predicate2 & pred2 ) const

inline

Return an iterator that replaces the predicate.

Advance to the first position at or after the old position that satisfies the new predicate, or to the end

Definition at line 547 of file Track.h.

   {
      return { this->mBegin, this->mIter, this->mEnd, pred2 };
   }

References TrackIter< TrackType >::mBegin, TrackIter< TrackType >::mEnd, and TrackIter< TrackType >::mIter.

Referenced by TrackList::Channels_().

Here is the caller graph for this function:

◆ GetPredicate()

template<typename TrackType >

const FunctionType & TrackIter< TrackType >::GetPredicate ( ) const

inline

Definition at line 567 of file Track.h.

568 { return this->mPred; }

References TrackIter< TrackType >::mPred.

◆ operator*()

template<typename TrackType >

TrackType * TrackIter< TrackType >::operator* ( ) const

inline

Safe to call even when at the end.

In that case you get nullptr.

Definition at line 614 of file Track.h.

   {
      if (this->mIter == this->mEnd)
         return nullptr;
      else
         // Other methods guarantee that the cast is correct
         // (provided no operations on the TrackList invalidated
         // underlying iterators or replaced the tracks there)
         return static_cast< TrackType * >( &**this->mIter );
   }

References TrackIter< TrackType >::mEnd, and TrackIter< TrackType >::mIter.

◆ operator++() [1/2]

template<typename TrackType >

TrackIter & TrackIter< TrackType >::operator++ ( )

inline

Safe to call even when at the end.

In that case *this remains unchanged.

Definition at line 572 of file Track.h.

   {
      // Maintain the class invariant
      if (this->mIter != this->mEnd) do
         ++this->mIter;
      while (this->mIter != this->mEnd && !this->valid() );
      return *this;
   }

References TrackIter< TrackType >::mEnd, TrackIter< TrackType >::mIter, and TrackIter< TrackType >::valid().

Referenced by TrackIter< TrackType >::operator++().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator++() [2/2]

template<typename TrackType >

TrackIter TrackIter< TrackType >::operator++ ( int )

inline

Safe to call even when at the end.

In that case *this remains unchanged.

Definition at line 582 of file Track.h.

   {
      TrackIter result { *this };
      this-> operator ++ ();
      return result;
   }

References TrackIter< TrackType >::operator++().

Here is the call graph for this function:

◆ operator--() [1/2]

template<typename TrackType >

TrackIter & TrackIter< TrackType >::operator-- ( )

inline

Safe to call even when at the beginning.

In that case *this wraps to the end.

Definition at line 591 of file Track.h.

   {
      // Maintain the class invariant
      do {
         if (this->mIter == this->mBegin)
            // Go circularly
            this->mIter = this->mEnd;
         else
            --this->mIter;
      } while (this->mIter != this->mEnd && !this->valid() );
      return *this;
   }

References TrackIter< TrackType >::mBegin, TrackIter< TrackType >::mEnd, TrackIter< TrackType >::mIter, and TrackIter< TrackType >::valid().

Referenced by TrackIter< TrackType >::operator--().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator--() [2/2]

template<typename TrackType >

TrackIter TrackIter< TrackType >::operator-- ( int )

inline

Safe to call even when at the beginning.

In that case *this wraps to the end.

Definition at line 605 of file Track.h.

   {
      TrackIter result { *this };
      this->operator -- ();
      return result;
   }

References TrackIter< TrackType >::operator--().

Here is the call graph for this function:

◆ valid()

template<typename TrackType >

bool TrackIter< TrackType >::valid ( ) const

inlineprivate

Test satisfaction of the invariant, while initializing, incrementing, or decrementing.

Precondition: underlying iterators are still valid, and mPred, if not null, is well behaved

Invariant: mIter == mEnd, or else, mIter != mEnd, and **mIter is of the appropriate subclass, and mPred is null or mPred(&**mIter) is true.

Definition at line 658 of file Track.h.

   {
      // assume mIter != mEnd
      const auto pTrack = track_cast< TrackType * >( &**this->mIter );
      if (!pTrack)
         return false;
      return !this->mPred || this->mPred( pTrack );
   }

References TrackIter< TrackType >::mIter, and TrackIter< TrackType >::mPred.

Referenced by TrackIter< TrackType >::operator++(), and TrackIter< TrackType >::operator--().

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ operator!=

template<typename TrackType >

bool operator!=	(	TrackIter< TrackType >	a,
		TrackIter< TrackType >	b
	)

friend

Compares only current positions, assuming same beginnings and ends.

Definition at line 647 of file Track.h.

   {
      return !(a == b);
   }

◆ operator==

template<typename TrackType >

bool operator==	(	TrackIter< TrackType >	a,
		TrackIter< TrackType >	b
	)

friend

Compares only current positions, assuming same beginnings and ends.

Definition at line 636 of file Track.h.

   {
      // Assume the predicate is not stateful.  Just compare the iterators.
      return
         a.mIter == b.mIter
         // Assume this too:
         // && a.mBegin == b.mBegin && a.mEnd == b.mEnd
      ;
   }

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

Track.h

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ FunctionType

Constructor & Destructor Documentation

◆ TrackIter()

Member Function Documentation

◆ advance()

◆ Filter() [1/2]

◆ Filter() [2/2]

◆ GetPredicate()

◆ operator*()

◆ operator++() [1/2]

◆ operator++() [2/2]

◆ operator--() [1/2]

◆ operator--() [2/2]

◆ valid()

Friends And Related Function Documentation

◆ operator!=

◆ operator==

Member Data Documentation

◆ mBegin

◆ mEnd

◆ mIter

◆ mPred

◆ TrackIterRange< TrackType >