Autres/audacity
1
0
Fork 0
mirror of https://github.com/cookiengineer/audacity synced 2025-05-02 08:39:46 +02:00
Code Issues Releases Wiki Activity

Remove old style track iterator classes

Browse Source
This commit is contained in:
Paul Licameli 2017-04-09 16:58:41 -04:00
parent fbec3efa0c
commit b5f52e7c1c
3 changed files with 7 additions and 512 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

322
src/Track.cpp
View File

@ -46,12 +46,6 @@ and TimeTrack.
#pragma warning( disable : 4786 )
#endif
#ifdef __WXDEBUG__
// if we are in a debug build of audacity
/// Define this to do extended (slow) debuging of TrackListIterator
// #define DEBUG_TLI
#endif
Track::Track(const std::shared_ptr<DirManager> &projDirManager)
: vrulerSize(36,0),
mDirManager(projDirManager)
@ -414,320 +408,6 @@ bool Track::IsLeader() const
bool Track::IsSelectedLeader() const
{ return IsSelected() && IsLeader(); }
// TrackListIterator
TrackListIterator::TrackListIterator(TrackList * val, TrackNodePointer p)
: l{ val }
, cur{ p }
{
}
TrackListIterator::TrackListIterator(TrackList * val)
: l{ val }
, cur{}
{
if (l)
cur = l->getBegin();
}
Track *TrackListIterator::StartWith(Track * val)
{
if (val == NULL) {
return First();
}
if (l == NULL) {
return NULL;
}
if (val->mList.lock() == NULL)
return nullptr;
cur = val->GetNode();
return cur.first->get();
}
Track *TrackListIterator::First(TrackList * val)
{
if (val != NULL) {
l = val;
}
if (l == NULL) {
return NULL;
}
cur = l->getBegin();
if (!l->isNull(cur)) {
return cur.first->get();
}
return nullptr;
}
Track *TrackListIterator::Last()
{
if (l == NULL) {
return NULL;
}
cur = l->getPrev( l->getEnd() );
if ( l->isNull( cur ) )
return nullptr;
return cur.first->get();
}
Track *TrackListIterator::Next()
{
#ifdef DEBUG_TLI // if we are debugging this bit
wxASSERT_MSG((!cur || (*l).Contains((*cur).t)), wxT("cur invalid at start of Next(). List changed since iterator created?")); // check that cur is in the list
#endif
if (!l || l->isNull(cur))
return nullptr;
cur = l->getNext( cur );
#ifdef DEBUG_TLI // if we are debugging this bit
wxASSERT_MSG((!cur || (*l).Contains((*cur).t)), wxT("cur invalid after moving to next track.")); // check that cur is in the list if it is not null
#endif
if (!l->isNull(cur))
return cur.first->get();
return nullptr;
}
Track *TrackListIterator::Prev()
{
if (!l || l->isNull(cur))
return nullptr;
cur = l->getPrev( cur );
if ( l->isNull( cur ) )
return nullptr;
return cur.first->get();
}
Track *TrackListIterator::operator *() const
{
if ( !l || l->isNull( cur ) )
return nullptr;
else
return cur.first->get();
}
bool TrackListIterator::operator == (const TrackListIterator &other) const
{
// Order these steps so as not to use operator == on default-constructed
// std::list::iterator -- that crashes in the MSVC 2013 standard library
bool isEnd = !l || l->isNull( cur );
bool otherIsEnd = !other.l || other.l->isNull( other.cur );
return (isEnd == otherIsEnd && (isEnd || cur == other.cur));
}
//
// TrackListCondIterator (base class for iterators that iterate over all tracks
// that meet a condition)
//
Track *TrackListCondIterator::StartWith(Track *val)
{
Track *t = TrackListIterator::StartWith(val);
if (t && !this->Condition(t))
return nullptr;
return t;
}
Track *TrackListCondIterator::First(TrackList *val)
{
Track *t = TrackListIterator::First(val);
while (t && !this->Condition(t)) {
t = TrackListIterator::Next();
}
return t;
}
Track *TrackListCondIterator::Next()
{
while (Track *t = TrackListIterator::Next()) {
if (this->Condition(t)) {
return t;
}
}
return NULL;
}
Track *TrackListCondIterator::Prev()
{
while (Track *t = TrackListIterator::Prev())
{
if (this->Condition(t)) {
return t;
}
}
return NULL;
}
Track *TrackListCondIterator::Last()
{
Track *t = TrackListIterator::Last();
while (t && !this->Condition(t)) {
t = TrackListIterator::Prev();
}
return t;
}
// TrackListOfKindIterator
TrackListOfKindIterator::TrackListOfKindIterator(TrackKind kind, TrackList * val)
: TrackListCondIterator(val)
{
this->kind = kind;
}
bool TrackListOfKindIterator::Condition(Track *t)
{
return kind == Track::All || t->GetKind() == kind;
}
//SelectedTrackListOfKindIterator
bool SelectedTrackListOfKindIterator::Condition(Track *t)
{
return TrackListOfKindIterator::Condition(t) && t->GetSelected();
}
// SyncLockedTracksIterator
//
// Based on TrackListIterator returns only tracks belonging to the group
// in which the starting track is a member.
//
SyncLockedTracksIterator::SyncLockedTracksIterator(TrackList * val)
: TrackListIterator(val),
mInLabelSection(false)
{
}
Track *SyncLockedTracksIterator::StartWith(Track * member)
{
Track *t = NULL;
// A sync-locked group consists of any positive number of wave (or note)
// tracks followed by any
// non-negative number of label tracks. Step back through any label tracks,
// and then through the wave tracks above them.
while (member && member->GetKind() == Track::Label) {
member = l->GetPrev(member);
}
while (member && IsSyncLockableNonLabelTrack(member)) {
t = member;
member = l->GetPrev(member);
}
// Make it current (if t is still NULL there are no wave tracks, so we're
// not in a sync-locked group).
if (t)
cur = t->GetNode();
mInLabelSection = false;
return t;
}
bool SyncLockedTracksIterator::IsGoodNextTrack(const Track *t) const
{
if (!t)
return false;
const bool isLabel = ( t->GetKind() == Track::Label );
const bool isSyncLockable = IsSyncLockableNonLabelTrack( t );
if ( !( isLabel || isSyncLockable ) ) {
return false;
}
if (mInLabelSection && !isLabel) {
return false;
}
return true;
}
Track *SyncLockedTracksIterator::Next()
{
Track *t = TrackListIterator::Next();
if (!t)
return nullptr;
if ( ! IsGoodNextTrack(t) ) {
cur = l->getEnd();
return nullptr;
}
mInLabelSection = ( t->GetKind() == Track::Label );
return t;
}
Track *SyncLockedTracksIterator::Prev()
{
Track *t = TrackListIterator::Prev();
//
// Ways to end a sync-locked group in reverse
//
// Beginning of tracks
if (!t)
return nullptr;
const bool isLabel = ( t->GetKind() == Track::Label );
const bool isSyncLockable = IsSyncLockableNonLabelTrack( t );
if ( !( isLabel || isSyncLockable ) ) {
cur = l->getEnd();
return nullptr;
}
if ( !mInLabelSection && isLabel ) {
cur = l->getEnd();
return nullptr;
}
mInLabelSection = isLabel;
return t;
}
Track *SyncLockedTracksIterator::Last()
{
if ( !l || l->isNull( cur ) )
return nullptr;
Track *t = cur.first->get();
while (const auto next = l->GetNext(t)) {
if ( ! IsGoodNextTrack(next) )
break;
t = Next();
}
return t;
}
std::pair<Track *, Track *> TrackList::FindSyncLockGroup(Track *pMember) const
{
if (!pMember)
@ -844,7 +524,7 @@ void TrackList::RecalcPositions(TrackNodePointer node)
}
const auto theEnd = end();
for (auto n = TrackListIterator{ this, node }; n != theEnd; ++n) {
for (auto n = Find( node.first->get() ); n != theEnd; ++n) {
t = *n;
t->SetIndex(i++);
t->DoSetY(y);

192
src/Track.h
View File

@ -191,8 +191,6 @@ class AUDACITY_DLL_API Track /* not final */
: public CommonTrackPanelCell, public XMLTagHandler
{
friend class TrackList;
friend class TrackListIterator;
friend class SyncLockedTracksIterator;
// To be TrackDisplay
private:
@ -416,16 +414,6 @@ public:
// to do: privatize this
virtual TrackKind GetKind() const { return TrackKind::None; }
// to do: remove these
static const TrackKind Label = TrackKind::Label;
#ifdef USE_MIDI
static const TrackKind Note = TrackKind::Note;
#endif
static const TrackKind Wave = TrackKind::Wave;
static const TrackKind Time = TrackKind::Time;
static const TrackKind All = TrackKind::All;
static const TrackKind None = TrackKind::None;
private:
template<typename T>
friend typename std::enable_if< std::is_pointer<T>::value, T >::type
@ -437,7 +425,6 @@ private:
T
>::type
track_cast(const Track *track);
friend class TrackListOfKindIterator;
public:
bool SameKindAs(const Track &track) const
@ -1079,170 +1066,6 @@ template <
}
};
class AUDACITY_DLL_API TrackListIterator /* not final */
: public std::iterator< std::forward_iterator_tag, Track *const >
{
public:
// The default-constructed value can serve as the end iterator for
// traversal over any track list.
TrackListIterator() {}
explicit TrackListIterator(TrackList * val);
explicit TrackListIterator(TrackList * val, TrackNodePointer p);
TrackListIterator(const TrackListIterator&) = default;
TrackListIterator& operator=(const TrackListIterator&) = default;
virtual ~TrackListIterator() {}
// Iterate functions
virtual Track *First(TrackList * val = nullptr);
virtual Track *StartWith(Track * val);
virtual Track *Next();
virtual Track *Prev();
virtual Track *Last();
// Provide minimal STL forward-iterator idiom:
// unlike Next, this is non-mutating.
// An end iterator may be safely dereferenced, returning nullptr.
Track *operator * () const;
TrackListIterator &operator++ () { (void) Next(); return *this; }
TrackListIterator operator++ (int)
{ auto copy = *this; operator++(); return copy; }
bool operator == (const TrackListIterator &other) const;
bool operator != (const TrackListIterator &other) const
{ return !(*this == other); }
protected:
friend TrackList;
TrackList *l {};
TrackNodePointer cur{};
};
class AUDACITY_DLL_API TrackListConstIterator
: public std::iterator< std::forward_iterator_tag, const Track *const >
{
public:
// The default-constructed value can serve as the end iterator for
// traversal over any track list.
TrackListConstIterator() {}
explicit TrackListConstIterator(
const TrackList * val, TrackNodePointer p)
: mIter(const_cast<TrackList*>(val), p)
{}
explicit TrackListConstIterator(
const TrackList * val)
: mIter(const_cast<TrackList*>(val))
{}
TrackListConstIterator(const TrackListConstIterator&) = default;
TrackListConstIterator& operator=(const TrackListConstIterator&) = default;
~TrackListConstIterator() {}
// Iterate functions
const Track *First(const TrackList * val = NULL)
{ return mIter.First(const_cast<TrackList*>(val)); }
const Track *StartWith(const Track * val)
{ return mIter.StartWith(const_cast<Track*>(val)); }
const Track *Next()
{ return mIter.Next(); }
const Track *Prev()
{ return mIter.Prev(); }
const Track *Last()
{ return mIter.Last(); }
// Provide minimal STL forward-iterator idiom:
// unlike Next, this is non-mutating.
// An end iterator may be safely dereferenced, returning nullptr.
const Track *operator * () const { return *mIter; }
TrackListConstIterator &operator++ () { (void) Next(); return *this; }
TrackListConstIterator operator++ (int)
{ auto copy = *this; operator++(); return copy; }
bool operator == (const TrackListConstIterator &other) const
{ return mIter == other.mIter; }
bool operator != (const TrackListConstIterator &other) const
{ return !(*this == other); }
private:
TrackListIterator mIter;
};
// TrackListCondIterator (base class for iterators that iterate over all tracks)
// that meet a condition)
class AUDACITY_DLL_API TrackListCondIterator /* not final */ : public TrackListIterator
{
public:
TrackListCondIterator(TrackList *val = NULL)
: TrackListIterator(val) {}
virtual ~TrackListCondIterator() {}
// Iteration functions
Track *First(TrackList *val = NULL) override;
Track *StartWith(Track *val) override;
Track *Next() override;
Track *Prev() override;
Track *Last() override;
protected:
// NEW virtual
virtual bool Condition(Track *t) = 0;
};
//
// TrackListOfKindIterator
//
// Based on TrackListIterator and returns only tracks of the specified type.
//
class AUDACITY_DLL_API TrackListOfKindIterator /* not final */ : public TrackListCondIterator
{
public:
TrackListOfKindIterator(TrackKind kind, TrackList * val = nullptr);
virtual ~TrackListOfKindIterator() {}
protected:
virtual bool Condition(Track *t) override;
private:
TrackKind kind;
};
//
// SelectedTrackListOfKindIterator
//
// Based on TrackListOfKindIterator and returns only tracks selected.
//
class AUDACITY_DLL_API SelectedTrackListOfKindIterator final : public TrackListOfKindIterator
{
public:
SelectedTrackListOfKindIterator(TrackKind kind, TrackList * val = NULL) : TrackListOfKindIterator(kind, val) {}
virtual ~SelectedTrackListOfKindIterator() {}
protected:
bool Condition(Track *t) override;
};
// SyncLockedTracksIterator returns only tracks belonging to the sync-locked tracks
// in which the starting track is a member.
class AUDACITY_DLL_API SyncLockedTracksIterator final : public TrackListIterator
{
public:
SyncLockedTracksIterator(TrackList * val);
virtual ~SyncLockedTracksIterator() {}
// Iterate functions
Track *StartWith(Track *member) override;
Track *Next() override;
Track *Prev() override;
Track *Last() override;
private:
bool IsGoodNextTrack(const Track *t) const;
bool mInLabelSection;
};
/** \brief TrackList is a flat linked list of tracks supporting Add, Remove,
* Clear, and Contains, plus serialization of the list of tracks.
@ -1305,14 +1128,13 @@ class TrackList final : public wxEvtHandler, public ListOfTracks
// Iteration
// Hide the inherited begin() and end()
using iterator = TrackListIterator;
using const_iterator = TrackListConstIterator;
using iterator = TrackIter<Track>;
using const_iterator = TrackIter<const Track>;
using value_type = Track *;
iterator begin() { return iterator{
this, { ListOfTracks::begin(), this } }; }
iterator end() { return {}; }
const_iterator begin() const { return const_iterator{ this }; }
const_iterator end() const { return {}; }
iterator begin() { return Any().begin(); }
iterator end() { return Any().end(); }
const_iterator begin() const { return Any().begin(); }
const_iterator end() const { return Any().end(); }
const_iterator cbegin() const { return begin(); }
const_iterator cend() const { return end(); }
@ -1472,8 +1294,6 @@ public:
}
friend class Track;
friend class TrackListIterator;
friend class SyncLockedTracksIterator;
/// For use in sorting: assume each iterator points into this list, no duplications
void Permute(const std::vector<TrackNodePointer> &permutation);

5
src/TrackPanel.cpp
View File

@ -89,11 +89,6 @@ subset of the TrackPanel methods from all over the place.
*//**************************************************************//**
\class TrackListIterator
\brief An iterator for a TrackList.
*//**************************************************************//**
\class TrackListNode
\brief Used by TrackList, points to a Track.