Holds multiple objects as a single attachment to Track. More...

#include <ChannelAttachments.h>

Inheritance diagram for ChannelAttachmentsBase:

Collaboration diagram for ChannelAttachmentsBase:

Public Types
using	Factory = std::function< std::shared_ptr< ChannelAttachment >(Track &, size_t)>

Public Member Functions
	ChannelAttachmentsBase (Track &track, Factory factory)

	~ChannelAttachmentsBase () override

	ChannelAttachmentsBase (const ChannelAttachmentsBase &)=delete

ChannelAttachmentsBase &	operator= (const ChannelAttachmentsBase &)=delete

	ChannelAttachmentsBase (ChannelAttachmentsBase &)=delete

ChannelAttachmentsBase &	operator= (ChannelAttachmentsBase &&other)

size_t	Size () const

void	CopyTo (Track &track) const override
	Copy state, for undo/redo purposes. More...

void	Reparent (const std::shared_ptr< Track > &parent) override
	Object may be shared among tracks but hold a special back-pointer to one of them; reassign it. More...

void	WriteXMLAttributes (XMLWriter &writer) const override
	Serialize persistent attributes. More...

bool	HandleXMLAttribute (const std::string_view &attr, const XMLAttributeValueView &valueView) override
	Deserialize an attribute, returning true if recognized. More...

void	MakeStereo (const std::shared_ptr< Track > &parent, ChannelAttachmentsBase &&other)

void	SwapChannels (const std::shared_ptr< Track > &parent)

void	Erase (const std::shared_ptr< Track > &parent, size_t index)

Public Member Functions inherited from TrackAttachment
virtual	~TrackAttachment ()

virtual void	CopyTo (Track &track) const
	Copy state, for undo/redo purposes. More...

virtual void	Reparent (const std::shared_ptr< Track > &parent)
	Object may be shared among tracks but hold a special back-pointer to one of them; reassign it. More...

virtual void	WriteXMLAttributes (XMLWriter &) const
	Serialize persistent attributes. More...

virtual bool	HandleXMLAttribute (const std::string_view &attr, const XMLAttributeValueView &valueView)
	Deserialize an attribute, returning true if recognized. More...

Public Member Functions inherited from ClientData::Base
virtual	~Base ()

Static Protected Member Functions
static ChannelAttachment &	Get (const AttachedTrackObjects::RegisteredFactory &key, Track &track, size_t iChannel)

static ChannelAttachment *	Find (const AttachedTrackObjects::RegisteredFactory &key, Track *pTrack, size_t iChannel)

Private Attributes
const Factory	mFactory

std::vector< std::shared_ptr< ChannelAttachment > >	mAttachments

Detailed Description

Holds multiple objects as a single attachment to Track.

Definition at line 51 of file ChannelAttachments.h.

Member Typedef Documentation

◆ Factory

using ChannelAttachmentsBase::Factory = std::function<std::shared_ptr<ChannelAttachment>(Track &, size_t)>

Definition at line 54 of file ChannelAttachments.h.

Constructor & Destructor Documentation

◆ ChannelAttachmentsBase() [1/3]

ChannelAttachmentsBase::ChannelAttachmentsBase	(	Track &	track,
		Factory	factory
	)

Definition at line 76 of file ChannelAttachments.cpp.

   : mFactory{ move(factory) }
{
   const auto nChannels = track.NChannels();
   for (size_t iChannel = 0; iChannel < nChannels; ++iChannel)
      mAttachments.push_back(mFactory(track, iChannel));
}

References anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, mAttachments, mFactory, and ChannelGroup::NChannels().

Here is the call graph for this function:

◆ ~ChannelAttachmentsBase()

ChannelAttachmentsBase::~ChannelAttachmentsBase ( )

overridedefault

◆ ChannelAttachmentsBase() [2/3]

ChannelAttachmentsBase::ChannelAttachmentsBase ( const ChannelAttachmentsBase & )

delete

◆ ChannelAttachmentsBase() [3/3]

ChannelAttachmentsBase::ChannelAttachmentsBase ( ChannelAttachmentsBase & )

delete

Member Function Documentation

◆ CopyTo()

void ChannelAttachmentsBase::CopyTo ( Track & track ) const

overridevirtual

Copy state, for undo/redo purposes.

Reimplemented from TrackAttachment.

Definition at line 86 of file ChannelAttachments.cpp.

{
   // Maybe making a narrow empty copy so limit to the other track's number
   // of channels
   const size_t nn = std::min(mAttachments.size(), track.NChannels());
   for (size_t ii = 0; ii < nn; ++ii) {
      if (mAttachments[ii])
         mAttachments[ii]->CopyTo(track, ii);
   }
}

References mAttachments, min(), and ChannelGroup::NChannels().

Here is the call graph for this function:

◆ Erase()

void ChannelAttachmentsBase::Erase	(	const std::shared_ptr< Track > &	parent,
		size_t	index
	)

Erase attachment at a given index, if it existed, moving later-indexed attachments to earlier indices

Calls Reparent, so it needs a track

Definition at line 156 of file ChannelAttachments.cpp.

{
   auto size = mAttachments.size();
   if (index < size) {
      mAttachments.erase(mAttachments.begin() + index);
      for (--size; index < size; ++index)
         if (auto &pAttachment = mAttachments[index])
            pAttachment->Reparent(parent, index);
   }
}

References mAttachments, and size.

◆ Find()

ChannelAttachment * ChannelAttachmentsBase::Find	(	const AttachedTrackObjects::RegisteredFactory &	key,
		Track *	pTrack,
		size_t	iChannel
	)

staticprotected

Precondition: !pTrack || iChannel < pTrack->NChannels()

Definition at line 61 of file ChannelAttachments.cpp.

{
   assert(!pTrack || iChannel < pTrack->NChannels());
   if (!pTrack)
      return nullptr;
   const auto pAttachments =
      pTrack->AttachedObjects::Find<ChannelAttachmentsBase>(key);
   // do not create on demand
   if (!pAttachments || iChannel >= pAttachments->mAttachments.size())
      return nullptr;
   return pAttachments->mAttachments[iChannel].get();
}

References anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, key, and mAttachments.

Referenced by ChannelAttachments< Attachment >::Find().

Here is the caller graph for this function:

◆ Get()

ChannelAttachment & ChannelAttachmentsBase::Get	(	const AttachedTrackObjects::RegisteredFactory &	key,
		Track &	track,
		size_t	iChannel
	)

staticprotected

Precondition: iChannel < track.NChannels()

Definition at line 42 of file ChannelAttachments.cpp.

{
   // Precondition of this function; satisfies precondition of factory below
   assert(iChannel < track.NChannels());
   auto &attachments = track.AttachedObjects::Get<ChannelAttachmentsBase>(key);
   auto &objects = attachments.mAttachments;
   if (iChannel >= objects.size())
      objects.resize(iChannel + 1);
   auto &pObject = objects[iChannel];
   if (!pObject) {
      // Create on demand
      pObject = attachments.mFactory(track, iChannel);
      assert(pObject); // Precondition of constructor
   }
   return *pObject;
}

References anonymous_namespace{StretchingSequenceIntegrationTest.cpp}::iChannel, key, mAttachments, mFactory, and ChannelGroup::NChannels().

Referenced by ChannelAttachments< Attachment >::Get().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleXMLAttribute()

bool ChannelAttachmentsBase::HandleXMLAttribute	(	const std::string_view &	attr,
		const XMLAttributeValueView &	valueView
	)

overridevirtual

Deserialize an attribute, returning true if recognized.

default recognizes no attributes, and returns false

Reimplemented from TrackAttachment.

Definition at line 115 of file ChannelAttachments.cpp.

{
   size_t ii = 0;
   return any_of(mAttachments.begin(), mAttachments.end(),
   [&](auto &pAttachment) {
      bool result = pAttachment &&
         pAttachment->HandleXMLAttribute(attr, valueView, ii);
      ++ii;
      return result;
   });
}

References mAttachments.

◆ MakeStereo()

void ChannelAttachmentsBase::MakeStereo	(	const std::shared_ptr< Track > &	parent,
		ChannelAttachmentsBase &&	other
	)

Append the other's attachments to this, assuming concrete subclasses are the same

Calls Reparent, so it needs a track

Precondition: typeid(*this) == typeid(other); Size() <= 1; other.Size() <= 1

Definition at line 128 of file ChannelAttachments.cpp.

{
   assert(typeid(*this) == typeid(other));
   assert(Size() <= 1);
   assert(other.Size() <= 1);
   if (mAttachments.empty())
      mAttachments.resize(1);
   auto index = mAttachments.size();
   for (auto &ptr : other.mAttachments) {
      if (auto &pAttachment = mAttachments.emplace_back(move(ptr)))
         pAttachment->Reparent(parent, index++);
   }
   other.mAttachments.clear();
}

References mAttachments, and Size().

Here is the call graph for this function:

◆ operator=() [1/2]

ChannelAttachmentsBase & ChannelAttachmentsBase::operator= ( ChannelAttachmentsBase && other )

Precondition: typeid(*this) == typeid(other); same factories (can't express that in code)

Definition at line 17 of file ChannelAttachments.cpp.

{
   assert(typeid(*this) == typeid(other));
   mAttachments = move(other.mAttachments);
   return *this;
}

References mAttachments.

◆ operator=() [2/2]

ChannelAttachmentsBase & ChannelAttachmentsBase::operator= ( const ChannelAttachmentsBase & )

delete

◆ Reparent()

void ChannelAttachmentsBase::Reparent ( const std::shared_ptr< Track > & parent )

overridevirtual

Object may be shared among tracks but hold a special back-pointer to one of them; reassign it.

default does nothing

Reimplemented from TrackAttachment.

Definition at line 97 of file ChannelAttachments.cpp.

{
   const size_t nn = mAttachments.size();
   for (size_t ii = 0; ii < nn; ++ii) {
      if (mAttachments[ii])
         mAttachments[ii]->Reparent(parent, ii);
   }
}

References mAttachments.

◆ Size()

size_t ChannelAttachmentsBase::Size ( ) const

inline

Definition at line 74 of file ChannelAttachments.h.

74{ return mAttachments.size(); }

Referenced by MakeStereo(), and SwapChannels().

Here is the caller graph for this function:

◆ SwapChannels()

void ChannelAttachmentsBase::SwapChannels ( const std::shared_ptr< Track > & parent )

Calls Reparent, so it needs a track

Precondition: Size() <= 2

Definition at line 144 of file ChannelAttachments.cpp.

{
   assert(Size() <= 2);
   if (mAttachments.empty())
      return;
   mAttachments.resize(2);
   std::swap(mAttachments[0], mAttachments[1]);
   for (auto ii : { 0, 1 })
      if (const auto &pAttachment = mAttachments[ii])
         pAttachment->Reparent(parent, ii);
}

References mAttachments, Size(), and anonymous_namespace{NoteTrack.cpp}::swap().

Here is the call graph for this function:

◆ WriteXMLAttributes()

void ChannelAttachmentsBase::WriteXMLAttributes ( XMLWriter & ) const

overridevirtual

Serialize persistent attributes.

default does nothing

Reimplemented from TrackAttachment.

Definition at line 106 of file ChannelAttachments.cpp.

{
   const size_t nn = mAttachments.size();
   for (size_t ii = 0; ii < nn; ++ii) {
      if (mAttachments[ii])
         mAttachments[ii]->WriteXMLAttributes(writer, ii);
   }
}

References mAttachments.

Member Data Documentation

◆ mAttachments

std::vector<std::shared_ptr<ChannelAttachment> > ChannelAttachmentsBase::mAttachments

private

Definition at line 124 of file ChannelAttachments.h.

Referenced by ChannelAttachmentsBase(), CopyTo(), Erase(), Find(), Get(), HandleXMLAttribute(), MakeStereo(), operator=(), Reparent(), SwapChannels(), and WriteXMLAttributes().

◆ mFactory

const Factory ChannelAttachmentsBase::mFactory

private

Definition at line 123 of file ChannelAttachments.h.

Referenced by ChannelAttachmentsBase(), and Get().

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

Public Types

Public Member Functions

Static Protected Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Factory

Constructor & Destructor Documentation

◆ ChannelAttachmentsBase() [1/3]

◆ ~ChannelAttachmentsBase()

◆ ChannelAttachmentsBase() [2/3]

◆ ChannelAttachmentsBase() [3/3]

Member Function Documentation

◆ CopyTo()

◆ Erase()

◆ Find()

◆ Get()

◆ HandleXMLAttribute()

◆ MakeStereo()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ Reparent()

◆ Size()

◆ SwapChannels()

◆ WriteXMLAttributes()

Member Data Documentation

◆ mAttachments

◆ mFactory