omni::patch::List Class Reference

#include <List.h>

Inheritance diagram for omni::patch::List:

Collaboration diagram for omni::patch::List:

Public Types
typedef std::map< QString, std::unique_ptr< Patch > >	container_type

Public Member Functions
Patch *	addPatch (QString const &_id, Id const &_typeId)
	Add new patch with given type id. Returns nullptr if input with typeid does not exist. More...
Patch *	addPatch (QString const &_id, Patch *)
	Input with id and return pointer to input when successfully added. More...
std::pair< QString, Patch * >	addPatch (Id const &_typeId)
	Add new input with given type id. Returns nullptr if input with typeid does not exist Id is automatically generated. More...
Patch *	getPatch (QString const &_id)
	Return pointer of input with id, nullptr if input does not exist. More...
Patch const *	getPatch (QString const &_id) const
	Return pointer of input with id, nullptr if input does not exist. More...
void	removePatch (QString const &_id)
void	clear ()
	Delete all patches. More...
QString	currentId () const
	Return ID of current patch. More...
void	setCurrentId (QString const &)
	Set current patch by id and deselected all other patches. More...
Patch *	operator[] (QString const &_id) const
	Return patch at index. More...
Patch *	current ()
	Returns pointer to current patch Returns nullptr if currentIdx_ == -1 or input list is empty. More...
void	selectPatch (QString const &_id, bool _select=true)
	Select / deselect patch. More...
bool	patchIsSelected (QString const &) const
	Return flag whether patch with id is selected. More...
void	fromStream (QDataStream &)
	Deserialize from stream. More...
void	toStream (QDataStream &) const
	Serialize to stream. More...

Private Member Functions
QString	generateId () const
	Generate a new id for input. More...

Private Attributes
std::set< QString >	selectedPatches_
	Ids of selected patches. More...

Member Typedef Documentation

typedef std::map<QString,std::unique_ptr<Patch> > omni::patch::List::container_type

Member Function Documentation

Patch * omni::patch::List::addPatch	(	QString const &	_id,
		Id const &	_typeId
	)

Add new patch with given type id. Returns nullptr if input with typeid does not exist.

Parameters

_id	Id for the patch
_typeId	Type id of patch to determine which kind of input is created

                                                                {
      std::unique_ptr<Patch> _patch(patch::Factory::create(_typeId));

      if (!_patch) return nullptr;

      container_type::operator[](_id) = std::move(_patch);
      return container_type::at(_id).get();
    }

Patch * omni::patch::List::addPatch	(	QString const &	_id,
		Patch *	_patch
	)

Input with id and return pointer to input when successfully added.

                                                            {
      if (container_type::count(_id) != 0) {
        return nullptr;
      }
             container_type::operator[](_id).reset(_patch);
      return container_type::operator[](_id).get();
    }

std::pair< QString, Patch * > omni::patch::List::addPatch

(

Id const &

_typeId

)

Add new input with given type id. Returns nullptr if input with typeid does not exist Id is automatically generated.

Parameters

_typeId

Type id of input to determine which kind of input is created

Returns

Pair with input id and pointer to added input

                                                             {
      auto _id = generateId();

      return std::make_pair(_id, addPatch(_id, _typeId));
    }

void omni::patch::List::clear

(

)

Delete all patches.

                              {
      container_type::clear();

      selectedPatches_.clear();
    }

Patch * omni::patch::List::current

(

)

Returns pointer to current patch Returns nullptr if currentIdx_ == -1 or input list is empty.

                          {
      return getPatch(currentId());
    }

QString omni::patch::List::currentId

(

)

const

Return ID of current patch.

Return ID of current input.

                                        {
      return selectedPatches_.empty() ? QString("") : *selectedPatches_.begin();
    }

void omni::patch::List::fromStream

(

QDataStream &

_is

)

Deserialize from stream.

                                          {
      int _size = 0;
      deserialize(_is, _size);

      for (int i = 0; i < _size; ++i) {
          auto _id = deserializeReturn<QString>(_is);
          deserializePtr(_is, [&](Id const& _typeId) ->
                         patch::Interface *
          {
            return addPatch(_id, _typeId);
          });
      }
      deserialize(_is,selectedPatches_);
    }

QString omni::patch::List::generateId ( ) const

private

Generate a new id for input.

                                   {
      QString _id("0");

      for (size_t i = 0; i <= size(); ++i) {
        _id = QString("%1").arg(i);

        if (getPatch(_id) == nullptr)
        {
          return _id;
        }
      }
      return _id;
    }

Patch * omni::patch::List::getPatch

(

QString const &

_id

)

Return pointer of input with id, nullptr if input does not exist.

                                                       {
      if (!container_type::count(_id)) return nullptr;

      return container_type::at(_id).get();
    }

Patch const * omni::patch::List::getPatch

(

QString const &

_id

)

const

Return pointer of input with id, nullptr if input does not exist.

                                                             {
      if (!container_type::count(_id)) return nullptr;

      return container_type::at(_id).get();
    }

Patch* omni::patch::List::operator[]

(

QString const &

_id

)

const

Return patch at index.

bool omni::patch::List::patchIsSelected

(

QString const &

_id

)

const

Return flag whether patch with id is selected.

                                                       {
      return selectedPatches_.count(_id) > 0;
    }

void omni::patch::List::removePatch

(

QString const &

_id

)

                                             {
      container_type::erase(_id);

      selectedPatches_.erase(_id);
    }

void omni::patch::List::selectPatch	(	QString const &	_id,
		bool	_select = true
	)

Select / deselect patch.

                                                           {
      auto *_patch = getPatch(_id);

      if (!_patch) return;

      if (_select) {
        selectedPatches_.insert(_id);
      } else {
        selectedPatches_.erase(_id);
      }
    }

void omni::patch::List::setCurrentId

(

QString const &

_currentId

)

Set current patch by id and deselected all other patches.

Set current input by ID.

                                                              {
      selectedPatches_.clear();

      if (getPatch(_currentId) == nullptr) {
        return;
      }
      selectedPatches_.insert(_currentId);
    }

void omni::patch::List::toStream

(

QDataStream &

_os

)

const

Serialize to stream.

                                              {
      serialize(_os, int(size()));

      for (auto& _idPatch : (*this)) {
          auto& _id    = _idPatch.first;
          auto& _patch = _idPatch.second;
          serialize(_os, _id);
          serialize(_os, _patch.get());
      }

      serialize(_os,selectedPatches_);
    }

Field Documentation

std::set<QString> omni::patch::List::selectedPatches_

private

Ids of selected patches.

---

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

• include/omni/patch/List.h
• src/lib/patch/List.cpp