#include <MetaDataList.h>

Inheritance diagram for Kwave::MetaDataList:

Collaboration diagram for Kwave::MetaDataList:

Public Types
typedef QMapIterator< QString, MetaData >	Iterator

typedef QMutableMapIterator< QString, MetaData >	MutableIterator

Public Member Functions
	MetaDataList ()

	MetaDataList (const MetaData &meta)

virtual	~MetaDataList ()

virtual QList< Kwave::MetaData >	toSortedList () const

virtual MetaDataList	selectByType (const QString &type) const

virtual MetaDataList	selectByScope (MetaData::Scope scope) const

virtual MetaDataList	selectByTracks (const QList< unsigned int > &tracks) const

virtual MetaDataList	selectByRange (sample_index_t first, sample_index_t last) const

virtual MetaDataList	selectByPosition (sample_index_t pos) const

virtual MetaDataList	selectByProperty (const QString &property) const

virtual MetaDataList	selectByValue (const QString &property, QVariant value) const

virtual bool	contains (const MetaData &metadata) const

virtual void	replace (const MetaDataList &list)

virtual void	add (const MetaData &metadata)

virtual void	add (const MetaDataList &list)

virtual void	remove (const MetaData &metadata)

virtual void	remove (const MetaDataList &list)

virtual void	cropByRange (sample_index_t first, sample_index_t last)

virtual void	cropByTracks (const QList< unsigned int > &tracks)

virtual MetaDataList	copy (sample_index_t offset, sample_index_t length, const QList< unsigned int > &tracks) const

void	merge (const MetaDataList &meta_data)

virtual void	deleteRange (sample_index_t offset, sample_index_t length, const QList< unsigned int > &tracks)

virtual void	shiftLeft (sample_index_t offset, sample_index_t shift, const QList< unsigned int > &tracks)

virtual void	shiftRight (sample_index_t offset, sample_index_t shift, const QList< unsigned int > &tracks)

virtual void	scalePositions (double scale, const QList< unsigned int > &tracks)

virtual void	insertTrack (unsigned int track)

virtual void	deleteTrack (unsigned int track)

virtual void	dump () const

Protected Member Functions
void	split (sample_index_t offset, const QList< unsigned int > &tracks)

Detailed Description

Definition at line 36 of file MetaDataList.h.

Member Typedef Documentation

◆ Iterator

typedef QMapIterator<QString, MetaData> Kwave::MetaDataList::Iterator

const iterator for the meta data list

Definition at line 41 of file MetaDataList.h.

◆ MutableIterator

typedef QMutableMapIterator<QString, MetaData> Kwave::MetaDataList::MutableIterator

mutable iterator for the meta data list

Definition at line 44 of file MetaDataList.h.

Constructor & Destructor Documentation

◆ MetaDataList() [1/2]

Kwave::MetaDataList::MetaDataList ( )

Default constructor

Definition at line 27 of file MetaDataList.cpp.

     :QMap<QString, Kwave::MetaData>()
 {
 }

◆ MetaDataList() [2/2]

Kwave::MetaDataList::MetaDataList ( const MetaData & meta )

explicit

Constructor, creates a meta data list with only one single meta data item. In some cases you need to pass a meta data list to a function but you have only a single meta data item, so this might be quite handy

Parameters

meta	const reference to a single meta data item

Definition at line 33 of file MetaDataList.cpp.

References add().

     :QMap<QString, Kwave::MetaData>()
 {
     add(meta);
 }

Here is the call graph for this function:

◆ ~MetaDataList()

Kwave::MetaDataList::~MetaDataList ( )

virtual

Destructor

Definition at line 40 of file MetaDataList.cpp.

41 {

42 }

Member Function Documentation

◆ add() [1/2]

void Kwave::MetaDataList::add ( const MetaData & metadata )

virtual

Adds a single meta data object to the list. If it is already present, the old version will be silently replaced. If the object is a null object and an object with the same ID exists in the list, this will work as remove().

Parameters

metadata the meta data object that should be added

Definition at line 260 of file MetaDataList.cpp.

References Kwave::MetaData::id(), and Kwave::MetaData::isNull().

Referenced by add(), Kwave::SignalManager::addLabel(), Kwave::MimeData::decode(), deleteRange(), merge(), MetaDataList(), Kwave::SignalManager::modifyLabel(), Kwave::AsciiDecoder::open(), replace(), scalePositions(), selectByPosition(), selectByProperty(), selectByRange(), selectByScope(), selectByTracks(), selectByValue(), shiftLeft(), shiftRight(), split(), Kwave::LabelList::toMetaDataList(), and Kwave::UndoModifyMetaDataAction::undo().

 {
     if (!metadata.isNull())
         (*this)[metadata.id()] = metadata;
     else
         remove(metadata);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add() [2/2]

void Kwave::MetaDataList::add ( const MetaDataList & list )

virtual

Adds a list of meta data objects to the list. Old versions of existing objects will be silently replaced.

Parameters

list	list of meta data objects that should be added

Definition at line 269 of file MetaDataList.cpp.

References add().

 {
     foreach (const Kwave::MetaData &metadata, list)
         add(metadata);
 }

Here is the call graph for this function:

◆ contains()

bool Kwave::MetaDataList::contains ( const MetaData & metadata ) const

virtual

Checks whether a meta data object is contained in this list, the check is based on the unique id of the meta data object.

Parameters

metadata the object to search

Returns: true if found, otherwise false

Definition at line 214 of file MetaDataList.cpp.

References Kwave::MetaData::id().

Referenced by remove(), replace(), selectByTracks(), and Kwave::UndoModifyMetaDataAction::undo().

 {
     QString id = metadata.id();
 
     Iterator it(*this);
     while (it.hasNext()) {
         it.next();
         const Kwave::MetaData &m = it.value();
         if (m.id() == id)
             return true;
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy()

Kwave::MetaDataList Kwave::MetaDataList::copy	(	sample_index_t	offset,
		sample_index_t	length,
		const QList< unsigned int > &	tracks
	)		const

virtual

copy elements from the meta data list that overlap a given range of samples (selects elements with scope "Range" as well as elements with scope "Position") and have a binding to a track.

Parameters

offset	index of the first sample
length	number of samples of the range
tracks	list of track indices

Returns: list with a copy of found meta data objects

Definition at line 390 of file MetaDataList.cpp.

References cropByRange(), and cropByTracks().

Referenced by Kwave::SignalManager::deleteRange(), deleteRange(), merge(), Kwave::SampleRatePlugin::run(), scalePositions(), shiftLeft(), shiftRight(), split(), Kwave::UndoDeleteAction::store(), and Kwave::UndoAddMetaDataAction::undo().

 {
     if (!length)
         return Kwave::MetaDataList(); // no range selected - empty list
 
     Kwave::MetaDataList list(*this);
     list.cropByRange(offset, offset + length - 1);
     list.cropByTracks(tracks);
     return list;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cropByRange()

void Kwave::MetaDataList::cropByRange	(	sample_index_t	first,
		sample_index_t	last
	)

virtual

Crops this list to a given range of samples. All position aware elements that are not covered by the given range will be removed, all covered elements will be adjusted.

Parameters

first	index of the first sample
last	index of the last sample

Definition at line 290 of file MetaDataList.cpp.

References Kwave::MetaData::Position, Kwave::MetaData::Range, Kwave::MetaData::scope(), Kwave::MetaData::STDPROP_END, Kwave::MetaData::STDPROP_POS, and Kwave::MetaData::STDPROP_START.

Referenced by copy(), and Kwave::SignalManager::save().

 {
 
     MutableIterator it(*this);
     while (it.hasNext()) {
         it.next();
         Kwave::MetaData &m = it.value();
 
         if (m.scope() & Kwave::MetaData::Position) {
             // if the meta data is bound to a position, remove it if
             // it is out of scope and adjust the position if it is
             // within the selection
             const QVariant v_pos = m[Kwave::MetaData::STDPROP_POS];
             bool ok = false;
             sample_index_t pos = static_cast<sample_index_t>(
                 v_pos.toULongLong(&ok));
             if (!ok) continue;
 
             if ((pos < first) || (pos > last)) {
                 // out of the selected area -> remove
                 it.remove();
                 continue;
             }
         } else if (m.scope() & Kwave::MetaData::Range) {
             // if the meta data is bound to a scope, remove it if
             // it does not overlap with the current selection,
             // otherwise clip it to the bounds of the current selection
             const QVariant v_start = m[Kwave::MetaData::STDPROP_START];
             bool ok = false;
             sample_index_t start = static_cast<sample_index_t>(
                 v_start.toULongLong(&ok));
             if (!ok) continue;
 
             const QVariant v_end = m[Kwave::MetaData::STDPROP_END];
             ok = false;
             sample_index_t end = static_cast<sample_index_t>(
                 v_start.toULongLong(&ok));
             if (!ok) continue;
 
             if ((end < start) || (start >= last)) {
                 // out of the selected area -> remove
                 it.remove();
                 continue;
             } else {
                 // clip to the seleced range
                 if (start < first) start = first;
                 if (end   > last)  end   = last;
 
                 // adjust start and end
                 m[Kwave::MetaData::STDPROP_START] = start;
                 m[Kwave::MetaData::STDPROP_END]   = end;
             }
 
         }
     }
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cropByTracks()

void Kwave::MetaDataList::cropByTracks ( const QList< unsigned int > & tracks )

virtual

Crops this list to a given set of tracks. All elements that are bound to a track or list of tracks which are not covered by the given selection will be removed. The tracks of the remaining elements will be re-numbered to start from zero and counted up without gaps.

Parameters

tracks list of track indices

Definition at line 350 of file MetaDataList.cpp.

References Kwave::MetaData::clear(), Kwave::MetaData::hasProperty(), Kwave::MetaData::scope(), Kwave::MetaData::STDPROP_TRACKS, Kwave::toUint(), and Kwave::MetaData::Track.

Referenced by copy(), and Kwave::SignalManager::save().

 {
     MutableIterator it(*this);
     while (it.hasNext()) {
         it.next();
         const Kwave::MetaData &m = it.value();
 
         if (m.scope() & Kwave::MetaData::Track) {
             if (m.hasProperty(Kwave::MetaData::STDPROP_TRACKS)) {
                 // convert the track list into a usable list of unsigned int
                 QList<QVariant> v_track_list =
                     m[Kwave::MetaData::STDPROP_TRACKS].toList();
                 QList<unsigned int> bound_tracks;
                 foreach (const QVariant &v, v_track_list) {
                     bool ok = false;
                     unsigned int t = v.toUInt(&ok);
                     if (ok) bound_tracks += t;
                 }
 
                 foreach (unsigned int t, bound_tracks)
                     if (!tracks.contains(t)) bound_tracks.removeAll(t);
                 if (bound_tracks.isEmpty()) {
                     // no overlapping track indices -> remove
                     it.remove();
                     continue;
                 }
 
                 // do the renumbering
                 v_track_list.clear();
                 for (int i = 0; i < bound_tracks.count(); i++)
                     v_track_list.append(Kwave::toUint(i));
 
                 // set a new track list
                 m[Kwave::MetaData::STDPROP_TRACKS] = v_track_list;
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deleteRange()

void Kwave::MetaDataList::deleteRange	(	sample_index_t	offset,
		sample_index_t	length,
		const QList< unsigned int > &	tracks
	)

virtual

delete elements from the meta data list that overlap a given range of samples (selects elements with scope "Range" as well as elements with scope "Position") and have a binding to a track.

Parameters

offset	index of the first sample
length	number of samples to delete
tracks	list of track indices, will be filled with copies of found meta data objects

Definition at line 530 of file MetaDataList.cpp.

References add(), Kwave::MetaData::boundTracks(), copy(), Kwave::MetaData::firstSample(), Kwave::MetaData::hasProperty(), Kwave::MetaData::lastSample(), Kwave::MetaData::Range, Kwave::MetaData::scope(), Kwave::MetaData::setProperty(), Kwave::MetaData::STDPROP_END, Kwave::MetaData::STDPROP_POS, Kwave::MetaData::STDPROP_START, and Kwave::MetaData::STDPROP_TRACKS.

Referenced by Kwave::SignalManager::deleteRange(), Kwave::SampleRatePlugin::run(), and Kwave::UndoAddMetaDataAction::undo().

 {
     const sample_index_t del_first = offset;
     const sample_index_t del_last  = offset + length - 1;
 
     if (!length) return;
 
     MutableIterator it(*this);
     while (it.hasNext()) {
         it.next();
         Kwave::MetaData &meta = it.value();
 
         sample_index_t meta_first  = meta.firstSample();
         sample_index_t meta_last   = meta.lastSample();
 
         // check: range overlap?
         if ((meta_first > del_last) || (meta_last  < del_first))
             continue;
 
         // only operate on the matching tracks:
         if (!tracks.isEmpty() &&
             meta.hasProperty(Kwave::MetaData::STDPROP_TRACKS)) {
 
             // determine list of overlapping/non-overlapping tracks
             QList<unsigned int> overlapping_tracks;
             QList<unsigned int> non_overlapping_tracks;
             QList<unsigned int> meta_tracks  = meta.boundTracks();
 
             foreach (unsigned int t, meta_tracks) {
                 if (tracks.contains(t))
                     overlapping_tracks.append(t);
                 else
                     non_overlapping_tracks.append(t);
             }
 
             // skip if no overlap
             if (overlapping_tracks.isEmpty())
                 continue;
 
             // split all data bound to non-overlapping tracks into
             // a separate meta data object
             if (!non_overlapping_tracks.isEmpty()) {
                 Kwave::MetaData copy = meta;
 
                 QVariantList list;
                 foreach (unsigned int t, overlapping_tracks)
                     list.append(QVariant(t));
                 meta.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                 list.clear();
                 foreach (unsigned int t, non_overlapping_tracks)
                     list.append(QVariant(t));
                 copy.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                 add(copy);
             }
         }
 
         /* --- we have a position/range/track overlap --- */
 
         // position bound -> remove completely
         if (meta.hasProperty(Kwave::MetaData::STDPROP_POS)) {
             it.remove();
             continue;
         }
 
         // complete overlap -> remove completely
         if ((meta.scope() & Kwave::MetaData::Range) &&
             (meta_first >= del_first) && (meta_last <= del_last)) {
             it.remove();
             continue;
         }
 
         // check: no range -> no adjustment
         if (!meta.hasProperty(Kwave::MetaData::STDPROP_START) ||
             !meta.hasProperty(Kwave::MetaData::STDPROP_END)) {
             continue;
         }
 
         // cut out a piece from the middle -> adjust right
         if ((del_first > meta_first) && (del_last < meta_last)) {
             meta_last -= length;
             meta[Kwave::MetaData::STDPROP_END] = QVariant(meta_last);
             continue;
         }
 
         // cut away a part from left
         if (del_last < meta_last) {
             meta[Kwave::MetaData::STDPROP_START] = QVariant(del_last + 1);
             continue;
         }
 
         // cut away a part from right
         if (del_first > meta_first) {
             meta[Kwave::MetaData::STDPROP_END] = QVariant(del_first - 1);
             continue;
         }
 
         Q_ASSERT(false); // we should never reach this, no overlap?
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deleteTrack()

void Kwave::MetaDataList::deleteTrack ( unsigned int track )

virtual

delete all meta data that was bound to a specific track and adjust the track indices of all meta data items after that track by minus one

Parameters

track index of the track that is to be deleted

Definition at line 959 of file MetaDataList.cpp.

References Kwave::MetaData::hasProperty(), and Kwave::MetaData::STDPROP_TRACKS.

Referenced by Kwave::SignalManager::deleteTrack().

 {
     const QString prop = Kwave::MetaData::STDPROP_TRACKS;
     MutableIterator it(*this);
     while (it.hasNext()) {
         it.next();
         Kwave::MetaData &m = it.value();
         if (m.hasProperty(prop)) {
             // iterate over the list of tracks
             QList<QVariant> old_list = m[prop].toList();
             QList<QVariant> new_list;
             foreach (const QVariant &v, old_list) {
                 bool ok = false;
                 unsigned int t = v.toUInt(&ok);
                 Q_ASSERT(ok);
                 if (!ok) continue;
                 if (t < track)
                     new_list.append(v);
                 else if (t > track)
                     new_list.append(QVariant(t - 1));
             }
             if (!new_list.isEmpty())
                 m[prop] = new_list; // set updated list of bound tracks
             else
                 it.remove(); // list is empty now -> delete whole item
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dump()

void Kwave::MetaDataList::dump ( ) const

virtual

dump all meta data to stdout (for debugging)

Definition at line 1062 of file MetaDataList.cpp.

References DBG, and Kwave::MetaData::dump().

Referenced by Kwave::SignalManager::executeCommand(), Kwave::SignalManager::loadFile(), and Kwave::DebugPlugin::run().

 {
     qDebug("--- meta data ---");
 
     Iterator it(*this);
     while (it.hasNext()) {
         it.next();
         const Kwave::MetaData &meta = it.value();
         qDebug("* meta data #%s", DBG(it.key()));
         meta.dump();
     }
     qDebug("-----------------");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ insertTrack()

void Kwave::MetaDataList::insertTrack ( unsigned int track )

virtual

makes place for a new track by adjusting the track indices of all meta data items after that track by plus one

Parameters

track index of the track that is inserted

Definition at line 934 of file MetaDataList.cpp.

References Kwave::MetaData::hasProperty(), and Kwave::MetaData::STDPROP_TRACKS.

Referenced by Kwave::SignalManager::insertTrack().

 {
     const QString prop = Kwave::MetaData::STDPROP_TRACKS;
     MutableIterator it(*this);
     while (it.hasNext()) {
         it.next();
         const Kwave::MetaData &m = it.value();
         if (m.hasProperty(prop)) {
             // iterate over the list of tracks
             QList<QVariant> old_list = m[prop].toList();
             QList<QVariant> new_list;
             foreach (const QVariant &v, old_list) {
                 bool ok = false;
                 unsigned int t = v.toUInt(&ok);
                 if (ok && (t >= track))
                     new_list.append(QVariant(t + 1));
                 else
                     new_list.append(v);
             }
             m[prop] = new_list; // set updated list of bound tracks
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ merge()

void Kwave::MetaDataList::merge ( const MetaDataList & meta_data )

Merges a list of other meta data items

Parameters

meta_data list of meta data items

Definition at line 403 of file MetaDataList.cpp.

References add(), Kwave::MetaData::boundTracks(), copy(), Kwave::MetaData::firstSample(), Kwave::MetaData::hasProperty(), Kwave::MetaData::keys(), Kwave::MetaData::lastSample(), Kwave::MetaData::positionBoundPropertyNames(), Kwave::MetaData::scope(), Kwave::MetaData::setProperty(), Kwave::MetaData::STDPROP_END, Kwave::MetaData::STDPROP_START, Kwave::MetaData::STDPROP_TRACKS, and Kwave::MetaData::STDPROP_TYPE.

Referenced by Kwave::SignalManager::mergeMetaData(), Kwave::SampleRatePlugin::run(), Kwave::UndoDeleteMetaDataAction::undo(), and Kwave::UndoDeleteAction::undo().

 {
     if (meta_data.isEmpty())
         return; // shortcut: bail out if empty
 
     const QStringList position_bound_properties =
         Kwave::MetaData::positionBoundPropertyNames();
 
     foreach (const Kwave::MetaData &meta, meta_data) {
         // check if some meta data with the same type already
         // exists at an overlapping position
         bool found = false;
         if (meta.hasProperty(Kwave::MetaData::STDPROP_TYPE)) {
             MutableIterator it(*this);
             while (it.hasNext()) {
                 it.next();
                 Kwave::MetaData &other = it.value();
 
                 /* --- analysis phase --- */
 
                 // check: both have the same type?
                 if (!other.hasProperty(Kwave::MetaData::STDPROP_TYPE))
                     continue;
                 if (other[Kwave::MetaData::STDPROP_TYPE] !=
                     meta[Kwave::MetaData::STDPROP_TYPE])
                     continue;
 
                 // check: sampe scope?
                 if (!(meta.scope() == other.scope()))
                     continue;
 
                 // check: ranges overlap or touch?
                 sample_index_t meta_first  = meta.firstSample();
                 sample_index_t meta_last   = meta.lastSample();
                 sample_index_t other_first = other.firstSample();
                 sample_index_t other_last  = other.lastSample();
                 if ((meta_last < other_first) && (meta_last + 1 != other_first))
                     continue;
                 if ((meta_first > other_last) && (meta_first != other_last + 1))
                     continue;
 
                 // determine list of overlapping/non-overlapping tracks
                 QList<unsigned int> overlapping_tracks;
                 QList<unsigned int> non_overlapping_tracks;
                 if (meta.hasProperty(Kwave::MetaData::STDPROP_TRACKS) &&
                     other.hasProperty(Kwave::MetaData::STDPROP_TRACKS))
                 {
                     QList<unsigned int> meta_tracks  = meta.boundTracks();
                     QList<unsigned int> other_tracks = other.boundTracks();
 
                     foreach (unsigned int t, meta_tracks) {
                         if (other_tracks.contains(t))
                             overlapping_tracks.append(t);
                         else
                             non_overlapping_tracks.append(t);
                     }
                 }
 
                 // check: no overlapping tracks?
                 if (overlapping_tracks.isEmpty())
                     continue;
 
                 // check: all non-positional properties have to match
                 bool match = true;
                 foreach (const QString &p, meta.keys()) {
                     if (!other.hasProperty(p)) {
                         match = false;
                         break;
                     }
 
                     // ignore internal properties
                     if (p == Kwave::MetaData::STDPROP_TRACKS)
                         continue;
                     if (position_bound_properties.contains(p))
                         continue;
 
                     if (meta[p] != other[p]) {
                         match = false;
                         break;
                     }
                 }
                 if (!match) continue;
 
                 /* --- merge phase --- */
 
                 found = true;
 
                 // split all data bound to non-overlapping tracks into
                 // a separate meta data object
                 if (!non_overlapping_tracks.isEmpty()) {
                     Kwave::MetaData copy = other;
 
                     QVariantList list;
                     foreach (unsigned int t, non_overlapping_tracks)
                         list.append(QVariant(t));
                     other.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                     list.clear();
                     foreach (unsigned int t, overlapping_tracks)
                         list.append(QVariant(t));
                     copy.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                     add(copy);
                 }
 
                 // merge range
                 if (other.hasProperty(Kwave::MetaData::STDPROP_START)) {
                     other.setProperty(
                         Kwave::MetaData::STDPROP_START,
                         qMin(meta_first, other_first));
                 }
                 if (other.hasProperty(Kwave::MetaData::STDPROP_END)) {
                     other.setProperty(
                         Kwave::MetaData::STDPROP_END,
                         qMax(meta_last, other_last));
                 }
             }
         }
 
         // no matching meta data item for merging found => add as new one
         if (!found) {
             add(meta);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove() [1/2]

void Kwave::MetaDataList::remove ( const MetaData & metadata )

virtual

Removes one meta data object from the list (if it exists).

Parameters

metadata the object that should be removed

Definition at line 276 of file MetaDataList.cpp.

References contains(), and Kwave::MetaData::id().

Referenced by Kwave::MimeData::decode(), and Kwave::SignalManager::deleteLabel().

 {
     if (contains(metadata))
         QMap<QString, Kwave::MetaData>::remove(metadata.id());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove() [2/2]

void Kwave::MetaDataList::remove ( const MetaDataList & list )

virtual

Removes a list of meta data objects from this list (if they exist).

Parameters

list	the list of meta data objects to remove

Definition at line 283 of file MetaDataList.cpp.

 {
     foreach (const Kwave::MetaData &metadata, list)
         remove(metadata);
 }

◆ replace()

void Kwave::MetaDataList::replace ( const MetaDataList & list )

virtual

Replaces all meta data objects that have the same type as one of the objects in the passed list with newer versions. If an object did not exist, it will be created. If an object is not in the passed list, it will be deleted.

Parameters

list	listof meta data objects that should be replaced

Note: affects only objects with a type that was found in the passed list

Definition at line 229 of file MetaDataList.cpp.

References add(), contains(), and Kwave::MetaData::STDPROP_TYPE.

 {
     if (list.isEmpty()) return;
 
     // find out which meta data types are affected
     QStringList types;
     foreach (const Kwave::MetaData &meta, list) {
         QString type = meta[Kwave::MetaData::STDPROP_TYPE].toString();
         if (!types.contains(type)) {
             // remember this type in our list
             types.append(type);
 
             // remove all elements of that type that are not in the new list
             MutableIterator it(*this);
             while (it.hasNext()) {
                 it.next();
                 Kwave::MetaData &m = it.value();
                 if (m[Kwave::MetaData::STDPROP_TYPE] == type) {
                     if (!list.contains(m)) {
                         it.remove();
                     }
                 }
             }
         }
     }
 
     // now the same as in add() has to be done
     add(list);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scalePositions()

void Kwave::MetaDataList::scalePositions	(	double	scale,
		const QList< unsigned int > &	tracks
	)

virtual

scale the positions or start/end of all elements by a given factor

Parameters

scale	the factor that is applied to all positions
tracks	list of track indices

Definition at line 839 of file MetaDataList.cpp.

References add(), Kwave::MetaData::boundTracks(), copy(), Kwave::MetaData::firstSample(), Kwave::MetaData::hasProperty(), Kwave::MetaData::lastSample(), SAMPLE_INDEX_MAX, Kwave::MetaData::setProperty(), Kwave::MetaData::STDPROP_END, Kwave::MetaData::STDPROP_POS, Kwave::MetaData::STDPROP_START, and Kwave::MetaData::STDPROP_TRACKS.

Referenced by Kwave::MimeData::decode().

 {
     MutableIterator it(*this);
     while (it.hasNext()) {
         it.next();
         Kwave::MetaData &meta = it.value();
 
         sample_index_t meta_first  = meta.firstSample();
         sample_index_t meta_last   = meta.lastSample();
 
         // only operate on the matching tracks:
         if (!tracks.isEmpty() &&
             meta.hasProperty(Kwave::MetaData::STDPROP_TRACKS)) {
 
             // determine list of overlapping/non-overlapping tracks
             QList<unsigned int> overlapping_tracks;
             QList<unsigned int> non_overlapping_tracks;
             QList<unsigned int> meta_tracks  = meta.boundTracks();
 
             foreach (unsigned int t, meta_tracks) {
                 if (tracks.contains(t))
                     overlapping_tracks.append(t);
                 else
                     non_overlapping_tracks.append(t);
             }
 
             // skip if no overlap
             if (overlapping_tracks.isEmpty())
                 continue;
 
             // split all data bound to non-overlapping tracks into
             // a separate meta data object
             if (!non_overlapping_tracks.isEmpty()) {
                 Kwave::MetaData copy = meta;
 
                 QVariantList list;
                 foreach (unsigned int t, overlapping_tracks)
                     list.append(QVariant(t));
                 meta.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                 list.clear();
                 foreach (unsigned int t, non_overlapping_tracks)
                     list.append(QVariant(t));
                 copy.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                 add(copy);
             }
         }
 
         /* --- we have a position/range/track overlap --- */
 
         // position bound -> move position
         if (meta.hasProperty(Kwave::MetaData::STDPROP_POS)) {
             bool ok = false;
             sample_index_t pos = static_cast<sample_index_t>(
                 meta[Kwave::MetaData::STDPROP_POS].toULongLong(&ok));
             if (!ok) continue;
 
             if ((pos * scale) <= SAMPLE_INDEX_MAX) {
                 // scale position
                 meta[Kwave::MetaData::STDPROP_POS] = (pos * scale);
             } else  {
                 // do not produce a coordinate overflow
                 // -> moving outside range means deleting!
                 it.remove();
             }
             continue;
         }
 
         // check: no range -> no adjustment
         if (!meta.hasProperty(Kwave::MetaData::STDPROP_START) ||
             !meta.hasProperty(Kwave::MetaData::STDPROP_END)) {
             continue;
         }
 
         // check: range overflow
         if ((meta_first * scale) >= SAMPLE_INDEX_MAX) {
             it.remove();
             continue;
         }
 
         // scale, clip end to maximum coordinate
         meta_last  = static_cast<sample_index_t>(
             qMin<double>(SAMPLE_INDEX_MAX, meta_last * scale));
         meta_first = static_cast<sample_index_t>(meta_first * scale);
 
         if (meta.hasProperty(Kwave::MetaData::STDPROP_START))
             meta[Kwave::MetaData::STDPROP_START] = QVariant(meta_first);
         if (meta.hasProperty(Kwave::MetaData::STDPROP_END))
             meta[Kwave::MetaData::STDPROP_END]   = QVariant(meta_last);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ selectByPosition()

Kwave::MetaDataList Kwave::MetaDataList::selectByPosition ( sample_index_t pos ) const

virtual

select elements from the meta data list that are exactly at a given position.

Parameters

pos	index of the sample to select

Returns: list with found meta data objects

Definition at line 158 of file MetaDataList.cpp.

References add(), Kwave::MetaData::hasProperty(), Kwave::MetaData::Position, Kwave::MetaData::scope(), and Kwave::MetaData::STDPROP_POS.

 {
     Kwave::MetaDataList list;
 
     Iterator it(*this);
     while (it.hasNext()) {
         it.next();
         const Kwave::MetaData &m = it.value();
         if (m.scope() == Kwave::MetaData::Position) {
             if (m.hasProperty(Kwave::MetaData::STDPROP_POS)) {
                 // check for position within the range
                 bool pos_ok = false;
                 const sample_index_t p =
                     m[Kwave::MetaData::STDPROP_POS].toLongLong(&pos_ok);
                 if (pos_ok && (p == pos))
                     list.add(m);
             }
         }
     }
     return list;
 }

Here is the call graph for this function:

◆ selectByProperty()

Kwave::MetaDataList Kwave::MetaDataList::selectByProperty ( const QString & property ) const

virtual

select elements from the meta data list that contain a given property.

Parameters

property the property to search for

Returns: list with found meta data objects

Definition at line 182 of file MetaDataList.cpp.

References add(), and Kwave::MetaData::hasProperty().

 {
     Kwave::MetaDataList list;
 
     Iterator it(*this);
     while (it.hasNext()) {
         it.next();
         const Kwave::MetaData &m = it.value();
         if (m.hasProperty(property))
             list.add(m);
     }
     return list;
 }

Here is the call graph for this function:

◆ selectByRange()

Kwave::MetaDataList Kwave::MetaDataList::selectByRange	(	sample_index_t	first,
		sample_index_t	last
	)		const

virtual

select elements from the meta data list that overlap a given range of samples (selects elements with scope "Range" as well as elements with scope "Position")

Parameters

first	index of the first sample
last	index of the last sample

Returns: list with found meta data objects

Definition at line 118 of file MetaDataList.cpp.

References add(), Kwave::MetaData::hasProperty(), Kwave::MetaData::Position, Kwave::MetaData::Range, Kwave::MetaData::scope(), Kwave::MetaData::STDPROP_END, Kwave::MetaData::STDPROP_POS, and Kwave::MetaData::STDPROP_START.

Referenced by Kwave::MimeData::encode().

 {
     Kwave::MetaDataList list;
 
     Iterator it(*this);
     while (it.hasNext()) {
         it.next();
         const Kwave::MetaData &m = it.value();
         if (m.scope() == Kwave::MetaData::Range) {
             if (m.hasProperty(Kwave::MetaData::STDPROP_START) &&
                 m.hasProperty(Kwave::MetaData::STDPROP_END))
             {
                 // check for overlap with a meta data that has a range
                 bool start_ok = false, end_ok = false;
                 const sample_index_t start =
                     m[Kwave::MetaData::STDPROP_START].toULongLong(&start_ok);
                 const sample_index_t end =
                     m[Kwave::MetaData::STDPROP_END].toULongLong(&end_ok);
                 if (!start_ok || !end_ok) continue;
 
                 if ((start <= last) && (end >= first))
                     list.add(m);
             }
         }
         else if (m.scope() == Kwave::MetaData::Position) {
             if (m.hasProperty(Kwave::MetaData::STDPROP_POS)) {
                 // check for position within the range
                 bool pos_ok = false;
                 const sample_index_t pos =
                     m[Kwave::MetaData::STDPROP_POS].toLongLong(&pos_ok);
                 if (pos_ok && (pos >= first) && (pos <= last))
                     list.add(m);
             }
         }
     }
     return list;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ selectByScope()

Kwave::MetaDataList Kwave::MetaDataList::selectByScope ( MetaData::Scope scope ) const

virtual

select elements from the meta data list that have a specific scope

Parameters

scope the scope to select

See also: Kwave::MetaData::Scope

Returns: list with found meta data objects

Definition at line 68 of file MetaDataList.cpp.

References add(), and Kwave::MetaData::scope().

 {
     Kwave::MetaDataList list;
 
     Iterator it(*this);
     while (it.hasNext()) {
         it.next();
         const Kwave::MetaData &m = it.value();
         if (m.scope() == scope)
             list.add(m);
     }
     return list;
 }

Here is the call graph for this function:

◆ selectByTracks()

Kwave::MetaDataList Kwave::MetaDataList::selectByTracks ( const QList< unsigned int > & tracks ) const

virtual

select elements from the meta data list that belong to a given track.

Parameters

tracks list of track indices to select

Returns: list with found meta data objects

Definition at line 84 of file MetaDataList.cpp.

References add(), contains(), Kwave::MetaData::hasProperty(), Kwave::MetaData::id(), and Kwave::MetaData::STDPROP_TRACKS.

Referenced by Kwave::SignalManager::deleteTrack(), Kwave::SignalManager::insertTrack(), and Kwave::SelectionItem::startDragging().

 {
     Kwave::MetaDataList list;
     Iterator it(*this);
     while (it.hasNext()) {
         // iterate over all meta data items
         it.next();
         const Kwave::MetaData &m = it.value();
         bool match = true;
         if (m.hasProperty(Kwave::MetaData::STDPROP_TRACKS)) {
             // iterate over the list of tracks of the item
             match = false;
             QList<QVariant> track_list =
                 m[Kwave::MetaData::STDPROP_TRACKS].toList();
             foreach (const QVariant &v, track_list) {
                 bool ok = false;
                 unsigned int t = v.toUInt(&ok);
                 Q_ASSERT(ok);
                 if (ok && (tracks.contains(t))) {
                     match = true;
                     break;
                 }
             }
         }
         if (match) {
             Q_ASSERT(!list.keys().contains(m.id()));
             if (!list.keys().contains(m.id())) list.add(m);
         }
     }
     return list;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ selectByType()

Kwave::MetaDataList Kwave::MetaDataList::selectByType ( const QString & type ) const

virtual

select elements from the meta data list that have the standard property STDPROP_TYPE set to a specific value.

Parameters

type	the type to select

See also: Kwave::MetaData::STDPROP_TYPE

Returns: list with found meta data objects

Definition at line 62 of file MetaDataList.cpp.

References selectByValue(), and Kwave::MetaData::STDPROP_TYPE.

Referenced by Kwave::MimeData::decode(), and Kwave::LabelList::LabelList().

 {
     return selectByValue(Kwave::MetaData::STDPROP_TYPE, type);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ selectByValue()

Kwave::MetaDataList Kwave::MetaDataList::selectByValue	(	const QString &	property,
		QVariant	value
	)		const

virtual

select elements from the meta data list that contain a given property and a given value

Parameters

property	the property to search for
value	the value that the property should have

Returns: list with found meta data objects

Definition at line 198 of file MetaDataList.cpp.

References add(), and Kwave::MetaData::hasProperty().

Referenced by selectByType().

 {
     Kwave::MetaDataList list;
 
     Iterator it(*this);
     while (it.hasNext()) {
         it.next();
         const Kwave::MetaData &m = it.value();
         if (m.hasProperty(property) && (m[property] == value))
             list.add(m);
     }
     return list;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shiftLeft()

void Kwave::MetaDataList::shiftLeft	(	sample_index_t	offset,
		sample_index_t	shift,
		const QList< unsigned int > &	tracks
	)

virtual

shift the positions or start/end of all elements that are after a given offset to the left.

Parameters

offset	index of the first sample
shift	number of samples to shift left
tracks	list of track indices

Definition at line 635 of file MetaDataList.cpp.

References add(), Kwave::MetaData::boundTracks(), copy(), Kwave::MetaData::firstSample(), Kwave::MetaData::hasProperty(), Kwave::MetaData::lastSample(), Kwave::MetaData::setProperty(), Kwave::MetaData::STDPROP_END, Kwave::MetaData::STDPROP_POS, Kwave::MetaData::STDPROP_START, and Kwave::MetaData::STDPROP_TRACKS.

Referenced by Kwave::MimeData::encode(), and Kwave::SignalManager::slotSamplesDeleted().

 {
     MutableIterator it(*this);
     while (it.hasNext()) {
         it.next();
         Kwave::MetaData &meta = it.value();
 
         sample_index_t meta_first  = meta.firstSample();
         sample_index_t meta_last   = meta.lastSample();
 
         // check: is it before the offset ?
         if (meta_first < offset)
             continue;
 
         // only operate on the matching tracks:
         if (!tracks.isEmpty() &&
             meta.hasProperty(Kwave::MetaData::STDPROP_TRACKS)) {
 
             // determine list of overlapping/non-overlapping tracks
             QList<unsigned int> overlapping_tracks;
             QList<unsigned int> non_overlapping_tracks;
             QList<unsigned int> meta_tracks  = meta.boundTracks();
 
             foreach (unsigned int t, meta_tracks) {
                 if (tracks.contains(t))
                     overlapping_tracks.append(t);
                 else
                     non_overlapping_tracks.append(t);
             }
 
             // skip if no overlap
             if (overlapping_tracks.isEmpty())
                 continue;
 
             // split all data bound to non-overlapping tracks into
             // a separate meta data object
             if (!non_overlapping_tracks.isEmpty()) {
                 Kwave::MetaData copy = meta;
 
                 QVariantList list;
                 foreach (unsigned int t, overlapping_tracks)
                     list.append(QVariant(t));
                 meta.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                 list.clear();
                 foreach (unsigned int t, non_overlapping_tracks)
                     list.append(QVariant(t));
                 copy.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                 add(copy);
             }
         }
 
         /* --- we have a position/range/track overlap --- */
 
         // position bound -> move position
         if (meta.hasProperty(Kwave::MetaData::STDPROP_POS)) {
             bool ok = false;
             sample_index_t pos = static_cast<sample_index_t>(
                 meta[Kwave::MetaData::STDPROP_POS].toULongLong(&ok));
             if (!ok) continue;
 
             if (pos >= shift) {
                 // shift position left
                 meta[Kwave::MetaData::STDPROP_POS] = pos - shift;
             } else  {
                 // do not produce negative coordinates
                 // -> moving into negative means deleting!
                 it.remove();
             }
             continue;
         }
 
         // check: no range -> no adjustment
         if (!meta.hasProperty(Kwave::MetaData::STDPROP_START) ||
             !meta.hasProperty(Kwave::MetaData::STDPROP_END)) {
             continue;
         }
 
         // check: moving into negative
         Q_ASSERT(meta_last >= shift);
         if (meta_last < shift) {
             it.remove();
             continue;
         }
 
         // move to the left, clip start to zero
         Q_ASSERT(meta_first >= shift);
         meta_first  = (meta_first >= shift) ? (meta_first - shift) : 0;
         meta_last  -= shift;
 
         if (meta.hasProperty(Kwave::MetaData::STDPROP_START))
             meta[Kwave::MetaData::STDPROP_START] = QVariant(meta_first);
         if (meta.hasProperty(Kwave::MetaData::STDPROP_END))
             meta[Kwave::MetaData::STDPROP_END]   = QVariant(meta_last);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shiftRight()

void Kwave::MetaDataList::shiftRight	(	sample_index_t	offset,
		sample_index_t	shift,
		const QList< unsigned int > &	tracks
	)

virtual

shift the positions or start/end of all elements that are after a given offset to the right.

Parameters

offset	index of the first sample
shift	number of samples to shift right
tracks	list of track indices

Definition at line 735 of file MetaDataList.cpp.

References add(), Kwave::MetaData::boundTracks(), copy(), Kwave::MetaData::firstSample(), Kwave::MetaData::hasProperty(), Kwave::MetaData::lastSample(), SAMPLE_INDEX_MAX, Kwave::MetaData::setProperty(), Kwave::MetaData::STDPROP_END, Kwave::MetaData::STDPROP_POS, Kwave::MetaData::STDPROP_START, and Kwave::MetaData::STDPROP_TRACKS.

Referenced by Kwave::MimeData::decode(), and Kwave::SignalManager::slotSamplesInserted().

 {
     MutableIterator it(*this);
     it.toBack();
     while (it.hasPrevious()) {
         it.previous();
         Kwave::MetaData &meta = it.value();
 
         sample_index_t meta_first  = meta.firstSample();
         sample_index_t meta_last   = meta.lastSample();
 
         // check: is it before the offset ?
         if (meta_last < offset)
             continue;
 
         // only operate on the matching tracks:
         if (!tracks.isEmpty() &&
             meta.hasProperty(Kwave::MetaData::STDPROP_TRACKS)) {
 
             // determine list of overlapping/non-overlapping tracks
             QList<unsigned int> overlapping_tracks;
             QList<unsigned int> non_overlapping_tracks;
             QList<unsigned int> meta_tracks  = meta.boundTracks();
 
             foreach (unsigned int t, meta_tracks) {
                 if (tracks.contains(t))
                     overlapping_tracks.append(t);
                 else
                     non_overlapping_tracks.append(t);
             }
 
             // skip if no overlap
             if (overlapping_tracks.isEmpty())
                 continue;
 
             // split all data bound to non-overlapping tracks into
             // a separate meta data object
             if (!non_overlapping_tracks.isEmpty()) {
                 Kwave::MetaData copy = meta;
 
                 QVariantList list;
                 foreach (unsigned int t, overlapping_tracks)
                     list.append(QVariant(t));
                 meta.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                 list.clear();
                 foreach (unsigned int t, non_overlapping_tracks)
                     list.append(QVariant(t));
                 copy.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                 add(copy);
             }
         }
 
         /* --- we have a position/range/track overlap --- */
 
         // position bound -> move position
         if (meta.hasProperty(Kwave::MetaData::STDPROP_POS)) {
             bool ok = false;
             sample_index_t pos = static_cast<sample_index_t>(
                 meta[Kwave::MetaData::STDPROP_POS].toULongLong(&ok));
             if (!ok) continue;
 
             Q_ASSERT(pos + shift >= pos);
             if (pos + shift >= pos) {
                 // shift position right
                 meta[Kwave::MetaData::STDPROP_POS] = pos + shift;
             } else  {
                 // do not produce a coordinate overflow
                 // -> moving outside range means deleting!
                 it.remove();
             }
             continue;
         }
 
         // check: no range -> no adjustment
         if (!meta.hasProperty(Kwave::MetaData::STDPROP_START) ||
             !meta.hasProperty(Kwave::MetaData::STDPROP_END)) {
             continue;
         }
 
         // check: range overflow
         Q_ASSERT(meta_first + shift >= meta_first);
         if (meta_first + shift < meta_first) {
             it.remove();
             continue;
         }
 
         // move to the right, clip end to maximum coordinate
         Q_ASSERT(meta_last + shift >= meta_last);
         meta_last  = (meta_last + shift >= meta_last) ?
             (meta_last + shift) : SAMPLE_INDEX_MAX;
         if (meta_first >= offset)
             meta_first += shift;
 
         if (meta.hasProperty(Kwave::MetaData::STDPROP_START))
             meta[Kwave::MetaData::STDPROP_START] = QVariant(meta_first);
         if (meta.hasProperty(Kwave::MetaData::STDPROP_END))
             meta[Kwave::MetaData::STDPROP_END]   = QVariant(meta_last);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ split()

void Kwave::MetaDataList::split	(	sample_index_t	offset,
		const QList< unsigned int > &	tracks
	)

protected

Splits the list at a given position. The given position will be the start of the new fragment(s), so that splitting multiple times at the same offset does not produce further fragments.

Parameters

offset	index of the sample position before which the list should be split
tracks	list of track indices

Definition at line 989 of file MetaDataList.cpp.

References add(), Kwave::MetaData::boundTracks(), copy(), Kwave::MetaData::firstSample(), Kwave::MetaData::hasProperty(), Kwave::MetaData::lastSample(), Kwave::MetaData::setProperty(), Kwave::MetaData::STDPROP_END, Kwave::MetaData::STDPROP_START, and Kwave::MetaData::STDPROP_TRACKS.

 {
     // check: splitting at offset zero makes no sense, but is not forbidden
     if (!offset) return;
 
     MutableIterator it(*this);
     while (it.hasNext()) {
         it.next();
         Kwave::MetaData &meta = it.value();
 
         sample_index_t meta_first  = meta.firstSample();
         sample_index_t meta_last   = meta.lastSample();
 
         // check: is the split done in our range?
         if ((offset <= meta_first) || (offset > meta_last))
             continue;
 
         // check: no range -> no splitting
         if (!meta.hasProperty(Kwave::MetaData::STDPROP_START) ||
             !meta.hasProperty(Kwave::MetaData::STDPROP_END)) {
             continue;
         }
 
         // only operate on the matching tracks:
         if (!tracks.isEmpty() &&
             meta.hasProperty(Kwave::MetaData::STDPROP_TRACKS)) {
 
             // determine list of overlapping/non-overlapping tracks
             QList<unsigned int> overlapping_tracks;
             QList<unsigned int> non_overlapping_tracks;
             QList<unsigned int> meta_tracks  = meta.boundTracks();
 
             foreach (unsigned int t, meta_tracks) {
                 if (tracks.contains(t))
                     overlapping_tracks.append(t);
                 else
                     non_overlapping_tracks.append(t);
             }
 
             // skip if no overlap
             if (overlapping_tracks.isEmpty())
                 continue;
 
             // split all data bound to non-overlapping tracks into
             // a separate meta data object
             if (!non_overlapping_tracks.isEmpty()) {
                 Kwave::MetaData copy = meta;
 
                 QVariantList list;
                 foreach (unsigned int t, overlapping_tracks)
                     list.append(QVariant(t));
                 meta.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                 list.clear();
                 foreach (unsigned int t, non_overlapping_tracks)
                     list.append(QVariant(t));
                 copy.setProperty(Kwave::MetaData::STDPROP_TRACKS, list);
 
                 add(copy);
             }
         }
 
         /* --- we have a range/track overlap --- */
 
         Kwave::MetaData copy = meta;
         copy[Kwave::MetaData::STDPROP_START] = QVariant(offset);
         meta[Kwave::MetaData::STDPROP_END]   = QVariant(offset - 1);
         add(copy);
     }
 }

Here is the call graph for this function:

◆ toSortedList()

QList< Kwave::MetaData > Kwave::MetaDataList::toSortedList ( ) const

virtual

Create a simple list of meta data items, sorted by the position of the first sample. All meta data items that do not correspond to a position or a "first" sample are mapped to the start (zero).

Returns: a QList of meta data, sorted by position

Definition at line 51 of file MetaDataList.cpp.

References isLessThan().

Referenced by Kwave::LabelList::LabelList().

 {
     QList<Kwave::MetaData> list = this->values();
 
     if (!list.isEmpty())
         std::stable_sort(list.begin(), list.end(), isLessThan);
 
     return list;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

libkwave/MetaDataList.h
libkwave/MetaDataList.cpp

Public Types

Public Member Functions

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ Iterator

◆ MutableIterator

Constructor & Destructor Documentation

◆ MetaDataList() [1/2]

◆ MetaDataList() [2/2]

◆ ~MetaDataList()

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ contains()

◆ copy()

◆ cropByRange()

◆ cropByTracks()

◆ deleteRange()

◆ deleteTrack()

◆ dump()

◆ insertTrack()

◆ merge()

◆ remove() [1/2]

◆ remove() [2/2]

◆ replace()

◆ scalePositions()

◆ selectByPosition()

◆ selectByProperty()

◆ selectByRange()

◆ selectByScope()

◆ selectByTracks()

◆ selectByType()

◆ selectByValue()

◆ shiftLeft()

◆ shiftRight()

◆ split()

◆ toSortedList()