piercedVector.tpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#ifndef __BITPIT_PIERCED_VECTOR_TPP__
#define __BITPIT_PIERCED_VECTOR_TPP__
 
namespace bitpit {

template<typename value_t, typename id_t>
PiercedVector<value_t, id_t>::PiercedVector()
    : PiercedVectorKernel<id_t>(),
      PiercedVectorStorage<value_t, id_t>(1, this, PiercedVectorKernel<id_t>::SYNC_MODE_DISABLED)
{
}

template<typename value_t, typename id_t>
PiercedVector<value_t, id_t>::PiercedVector(std::size_t n)
    : PiercedVectorKernel<id_t>(n),
      PiercedVectorStorage<value_t, id_t>(1, this, PiercedVectorKernel<id_t>::SYNC_MODE_DISABLED)
{
}

template<typename value_t, typename id_t>
PiercedVector<value_t, id_t>::PiercedVector(const PiercedVector<value_t, id_t> &other)
    : PiercedVectorKernel<id_t>(other),
      PiercedVectorStorage<value_t, id_t>(other, this, other.getSyncMode())
{
    // Since we have copied the kernel, the list of registered slaves contains
    // also the internal storage of other vector. We need to unregister that
    // storage from the kernel.
    this->unregisterSlave(&other);
}

template<typename value_t, typename id_t>
PiercedVector<value_t, id_t>::PiercedVector(PiercedVector<value_t, id_t> &&other)
    : PiercedVectorKernel<id_t>(std::move(other)),
      PiercedVectorStorage<value_t, id_t>(std::move(other), this, other.getSyncMode())
{
    // Since we have moved the kernel, the list of registered slaves contains
    // also the internal storage of other vector. We need to unregister that
    // storage from the kernel.
    this->unregisterSlave(&other);
}

template<typename value_t, typename id_t>
PiercedVector<value_t, id_t> & PiercedVector<value_t, id_t>::operator=(const PiercedVector<value_t, id_t> &other)
{
    PiercedVector<value_t, id_t> temporary(other);
    this->swap(temporary);
 
    return *this;
}

template<typename value_t, typename id_t>
PiercedVector<value_t, id_t> & PiercedVector<value_t, id_t>::operator=(PiercedVector<value_t, id_t> &&other)
{
    this->swap(other);
 
    return *this;
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::reclaim(id_t id)
{
    // Fill a position
    FillAction reclaimAction = PiercedVectorKernel<id_t>::fillHead(id);
 
    // Reclaim the element associated to the position
    return reclaimValue(reclaimAction);
}

* Gets an element marked as empty and assignes to it the specified
* id. The element will have a position that is between the element
* with the specified reference id and the end of the container.
* Except for setting the id, the element is not modified. Therefore
* it will still contain the data of the element that was previously
* occupying the position or it will be empty if there was no empty
* position and a new element has been created.
* The container is extended by inserting a new element. The element
* will be inserted .
*
* \param referenceId is the id of the element after which an
* empty position will be reclaimed
* \param id is the id that will be assigned to the element
* \result An iterator that points to the newly inserted element.
*/
template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::reclaimAfter(const id_t &referenceId, id_t id)
{
    // Fill a position
    FillAction reclaimAction = PiercedVectorKernel<id_t>::fillAfter(referenceId, id);
 
    // Reclaim the element associated to the position
    return reclaimValue(reclaimAction);
}

/**
* Gets an element from the first position marked as empty
* past the last element assignes to it the specified id.
* Except for setting the id, the element is not modified.
* Therefore it will still contain the data of the element
* that was previously occupying the position or it will be
* empty if there was no empty position and a new element
* has been created.
*
* \param id is the id that will be assigned to the element
*/
template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::reclaimBack(id_t id)
{
    // Fill a position
    FillAction reclaimAction = PiercedVectorKernel<id_t>::fillAppend(id);
 
    // Reclaim the element associated to the position
    return reclaimValue(reclaimAction);
}

* Gets an element marked as empty and assignes to it the specified
* id. The element will have a position that is between the begin
* of the container and the specified reference id.
* Except for setting the id, the element is not modified. Therefore
* it will still contain the data of the element that was previously
* occupying the position or it will be empty if there was no empty
* position and a new element has been created.
* The container is extended by inserting a new element. The element
* will be inserted .
*
* \param referenceId is the id of the element before which an
* empty position will be reclaimed
* \param id is the id that will be assigned to the element
* \result An iterator that points to the newly inserted element.
*/
template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::reclaimBefore(const id_t &referenceId, id_t id)
{
    // Fill a position
    FillAction reclaimAction = PiercedVectorKernel<id_t>::fillBefore(referenceId, id);
 
    // Reclaim the element associated to the position
    return reclaimValue(reclaimAction);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::moveBefore(const id_t &referenceId, id_t id, bool delayed)
{
    // Update the position of the element in the kernel
    MoveAction moveAction = PiercedVectorKernel<id_t>::moveBefore(referenceId, id, !delayed);
 
    // Move the element to the new position
    return moveValue(moveAction);
}

/**
* Move the specified element after the element with the given
* reference id.
*
* \param referenceId is the id of the element after which the
* new element will be moved
* \param id is the id of the element that will be moved
* \param delayed if true some changes can remain in a pending state
* until a flush is called
* \result An iterator that points to the moved element.
*/
template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::moveAfter(const id_t &referenceId, id_t id, bool delayed)
{
    // Update the position of the element in the kernel
    MoveAction moveAction = PiercedVectorKernel<id_t>::moveAfter(referenceId, id, !delayed);
 
    // Move the element to the new position
    return moveValue(moveAction);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::insert(id_t id, const value_t &value)
{
    // Fill a position
    FillAction insertAction = PiercedVectorKernel<id_t>::fillHead(id);
 
    // Insert the new value
    return insertValue(insertAction, value);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::insertAfter(const id_t &referenceId, id_t id, const value_t &value)
{
    // Fill a position
    FillAction insertAction = PiercedVectorKernel<id_t>::fillAfter(referenceId, id);
 
    // Insert the new value
    return insertValue(insertAction, value);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::insertBefore(const id_t &referenceId, id_t id, const value_t &value)
{
    // Fill a position
    FillAction insertAction = PiercedVectorKernel<id_t>::fillBefore(referenceId, id);
 
    // Insert the new value
    return insertValue(insertAction, value);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::replace(id_t id, value_t &&value)
{
    // Position
    std::size_t pos = PiercedVectorKernel<id_t>::getPos(id);
 
    // Replace the value
    PiercedVectorStorage<value_t, id_t>::rawSet(pos, std::move(value));
 
    // Return the iterator that points to the element
    return PiercedVectorStorage<value_t, id_t>::rawFind(pos);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::pushBack(id_t id, const value_t &value)
{
    // Fill a position
    FillAction insertAction = PiercedVectorKernel<id_t>::fillAppend(id);
 
    // Insert the new value
    return insertValue(insertAction, value);
}

template<typename value_t, typename id_t>
template<typename... Args, typename PiercedStorage<value_t, id_t>::template EnableIfHasInitialize<Args...> * >
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::emreclaim(id_t id, Args&&... args)
{
    // Fill a position
    FillAction emplaceAction = PiercedVectorKernel<id_t>::fillHead(id);
 
    // Create the new value in-place
    return emreclaimValue<Args...>(emplaceAction, std::forward<Args>(args)...);
}

template<typename value_t, typename id_t>
template<typename... Args, typename PiercedStorage<value_t, id_t>::template EnableIfHasInitialize<Args...> * >
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::emreclaimAfter(const id_t &referenceId, id_t id, Args&&... args)
{
    // Fill a position
    FillAction emplaceAction = PiercedVectorKernel<id_t>::fillAfter(referenceId, id);
 
    // Create the new value in-place
    return emreclaimValue(emplaceAction, std::forward<Args>(args)...);
}

template<typename value_t, typename id_t>
template<typename... Args, typename PiercedStorage<value_t, id_t>::template EnableIfHasInitialize<Args...> * >
void PiercedVector<value_t, id_t>::emreclaimBack(id_t id, Args&&... args)
{
    // Fill a position
    FillAction emplaceAction = PiercedVectorKernel<id_t>::fillAppend(id);
 
    // Create the new value in-place
    emreclaimValue(emplaceAction, std::forward<Args>(args)...);
}

template<typename value_t, typename id_t>
template<typename... Args, typename PiercedStorage<value_t, id_t>::template EnableIfHasInitialize<Args...> * >
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::emreclaimBefore(const id_t &referenceId, id_t id, Args&&... args)
{
    // Fill a position
    FillAction emplaceAction = PiercedVectorKernel<id_t>::fillBefore(referenceId, id);
 
    // Create the new value in-place
    return emreclaimValue(emplaceAction, std::forward<Args>(args)...);
}

template<typename value_t, typename id_t>
template<typename... Args>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::emplace(id_t id, Args&&... args)
{
    // Fill a position
    FillAction emplaceAction = PiercedVectorKernel<id_t>::fillHead(id);
 
    // Create the new value in-place
    return emplaceValue(emplaceAction, std::forward<Args>(args)...);
}

template<typename value_t, typename id_t>
template<typename... Args>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::emplaceAfter(const id_t &referenceId, id_t id, Args&&... args)
{
    // Fill a position
    FillAction emplaceAction = PiercedVectorKernel<id_t>::fillAfter(referenceId, id);
 
    // Create the new value in-place
    return emplaceValue(emplaceAction, std::forward<Args>(args)...);
}

template<typename value_t, typename id_t>
template<typename... Args>
void PiercedVector<value_t, id_t>::emplaceBack(id_t id, Args&&... args)
{
    // Fill a position
    FillAction emplaceAction = PiercedVectorKernel<id_t>::fillAppend(id);
 
    // Create the new value in-place
    emplaceValue(emplaceAction, std::forward<Args>(args)...);
}

template<typename value_t, typename id_t>
template<typename... Args>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::emplaceBefore(const id_t &referenceId, id_t id, Args&&... args)
{
    // Fill a position
    FillAction emplaceAction = PiercedVectorKernel<id_t>::fillBefore(referenceId, id);
 
    // Create the new value in-place
    return emplaceValue(emplaceAction, std::forward<Args>(args)...);
}

template<typename value_t, typename id_t>
template<typename... Args>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::emreplace(id_t id, Args&&... args)
{
    // Position
    std::size_t pos = PiercedVectorKernel<id_t>::getPos(id);
 
    // Replace the value
    PiercedVectorStorage<value_t, id_t>::rawEmreplace(pos, std::forward<Args>(args)...);
 
    // Return the iterator that points to the element
    return PiercedVectorStorage<value_t, id_t>::rawFind(pos);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::erase(id_t id, bool delayed)
{
    // Erase the position
    EraseAction eraseAction = PiercedVectorKernel<id_t>::erase(id, !delayed);
 
    // Erase the value
    return eraseValue(eraseAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::popBack()
{
    // Erase the position
    EraseAction eraseAction = PiercedVectorKernel<id_t>::popBack();
 
    // Erase the value
    eraseValue(eraseAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::swap(id_t id_first, id_t id_second)
{
    // Update the kernel
    SwapAction swapAction = PiercedVectorKernel<id_t>::swap(id_first, id_second);
 
    // Update the storage
    swapValues(swapAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::clear(bool release)
{
    // Update the kernel
    ClearAction clearAction = PiercedVectorKernel<id_t>::clear(release);
 
    // Update the storage
    PiercedVectorStorage<value_t, id_t>::commitSyncAction(clearAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::reserve(std::size_t n)
{
    // Update the kernel
    ReserveAction reserveAction = PiercedVectorKernel<id_t>::reserve(n);
 
    // Update the storage
    PiercedVectorStorage<value_t, id_t>::commitSyncAction(reserveAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::resize(std::size_t n)
{
    // Update the kernel
    ResizeAction resizeAction = PiercedVectorKernel<id_t>::resize(n);
 
    // Update the storage
    PiercedVectorStorage<value_t, id_t>::commitSyncAction(resizeAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::sort()
{
    // Update the kernel
    SortAction sortAction = PiercedVectorKernel<id_t>::sort();
 
    // Update the storage
    PiercedVectorStorage<value_t, id_t>::commitSyncAction(sortAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::sortAfter(id_t referenceId, bool inclusive)
{
    // Update the kernel
    SortAction sortAction = PiercedVectorKernel<id_t>::sortAfter(referenceId, inclusive);
 
    // Update the storage
    PiercedVectorStorage<value_t, id_t>::commitSyncAction(sortAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::sortBefore(id_t referenceId, bool inclusive)
{
    // Update the kernel
    SortAction sortAction = PiercedVectorKernel<id_t>::sortBefore(referenceId, inclusive);
 
    // Update the storage
    PiercedVectorStorage<value_t, id_t>::commitSyncAction(sortAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::squeeze()
{
    // Update the kernel
    SqueezeAction squeezeAction = PiercedVectorKernel<id_t>::squeeze();
 
    // Update the storage
    PiercedVectorStorage<value_t, id_t>::commitSyncAction(squeezeAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::shrinkToFit()
{
    // Update the kernel
    ShrinkToFitAction shrinkToFitAction = PiercedVectorKernel<id_t>::shrinkToFit();
 
    // Update the storage
    PiercedVectorStorage<value_t, id_t>::commitSyncAction(shrinkToFitAction);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::swap(PiercedVector &other) noexcept
{
    // The swap will swap also the slave-master information. This is not what
    // we want, therefore the two pierced storage will be unregistered and the
    // registered again after the swap. When the kernel is unset the storage
    // can't be clear, otherwise its contents will be lost.
    PiercedVectorStorage<value_t, id_t>::detachKernel();
    other.PiercedVectorStorage<value_t, id_t>::detachKernel();
 
    // Swap kernel data
    PiercedVectorKernel<id_t>::swap(other);
 
    // Swap storage data
    PiercedVectorStorage<value_t, id_t>::swap(other);
 
    // Re-register the storages
    //
    // The function that sets a dynamic kernel may throw an exception if the
    // kernel is already set or if we are trying to set a null kernel. Here
    // neither of the two cases can happen, because the kernel has been
    // previously cleared and the kernel we are trying to set is not null.
    try {
        PiercedVectorStorage<value_t, id_t>::setDynamicKernel(this, PiercedVectorKernel<id_t>::SYNC_MODE_DISABLED);
        other.PiercedVectorStorage<value_t, id_t>::setDynamicKernel(&other, PiercedVectorKernel<id_t>::SYNC_MODE_DISABLED);
    } catch (const std::exception &exception) {
        BITPIT_UNUSED(exception);
        assert(false && "Error while swapping the PiercedVector!");
        std::cout << "Error while swapping the PiercedVector!" << std::endl;
        exit(0);
    }
}

template<typename value_t, typename id_t>
const PiercedVectorKernel<id_t> & PiercedVector<value_t, id_t>::getKernel() const
{
    return *this;
}

template<typename value_t, typename id_t>
const PiercedVectorStorage<value_t, id_t> & PiercedVector<value_t, id_t>::getStorage() const
{
    return *this;
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::dump() const
{
    PiercedVectorKernel<id_t>::dump();
}

template<typename value_t, typename id_t>
template<typename T, typename std::enable_if<std::is_pod<T>::value || PiercedVectorStorage<T, id_t>::has_restore()>::type *>
void PiercedVector<value_t, id_t>::restore(std::istream &stream)
{
    restoreKernel(stream);
 
    PiercedVectorStorage<T, id_t>::restore(stream);
}

template<typename value_t, typename id_t>
template<typename T, typename std::enable_if<std::is_pod<T>::value || PiercedVectorStorage<T, id_t>::has_dump()>::type *>
void PiercedVector<value_t, id_t>::dump(std::ostream &stream) const
{
    dumpKernel(stream);
 
    PiercedVectorStorage<T, id_t>::dump(stream);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::restoreKernel(std::istream &stream)
{
    PiercedVectorKernel<id_t>::restore(stream);
 
    PiercedVectorStorage<value_t, id_t>::rawResize(PiercedVectorKernel<id_t>::rawSize());
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::dumpKernel(std::ostream &stream) const
{
    PiercedVectorKernel<id_t>::dump(stream);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::reclaimValue(const FillAction &action)
{
    std::size_t pos = action.info[PiercedSyncAction::INFO_POS];
    switch (static_cast<typename FillAction::FillActionType>(action.type)) {
 
    case FillAction::TYPE_OVERWRITE:
    {
        // Nothing to do
        break;
    }
 
    case FillAction::TYPE_INSERT:
    {
        // Since we are increasing the sotrage by an element at the time
        // calling a reserve will hurt performance badly because this will
        // prevent the automatic reallocation of the storage.
        PiercedVectorStorage<value_t, id_t>::rawEmplace(pos);
        break;
    }
 
    case FillAction::TYPE_APPEND:
    {
        // Since we are increasing the sotrage by an element at the time
        // calling a reserve will hurt performance badly because this will
        // prevent the automatic reallocation of the storage.
        PiercedVectorStorage<value_t, id_t>::rawEmplaceBack();
        pos = PiercedVectorKernel<id_t>::getLastUsedPos();
        break;
    }
 
    default:
    {
        BITPIT_UNREACHABLE("This action is not handled");
        break;
    }
 
    }
 
    // Return the iterator to the position where the element was inserted
    return PiercedVectorStorage<value_t, id_t>::rawFind(pos);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::insertValue(const FillAction &action, const value_t &value)
{
    std::size_t pos = action.info[PiercedSyncAction::INFO_POS];
    switch (static_cast<typename FillAction::FillActionType>(action.type)) {
 
    case FillAction::TYPE_OVERWRITE:
    {
        PiercedVectorStorage<value_t, id_t>::rawSet(pos, value);
        break;
    }
 
    case FillAction::TYPE_INSERT:
    {
        // Since we are increasing the sotrage by an element at the time
        // calling a reserve will hurt performance badly because this will
        // prevent the automatic reallocation of the storage.
        PiercedVectorStorage<value_t, id_t>::rawInsert(pos, 1, value);
        break;
    }
 
    case FillAction::TYPE_APPEND:
    {
        // Since we are increasing the sotrage by an element at the time
        // calling a reserve will hurt performance badly because this will
        // prevent the automatic reallocation of the storage.
        PiercedVectorStorage<value_t, id_t>::rawPushBack(value);
        pos = PiercedVectorKernel<id_t>::getLastUsedPos();
        break;
    }
 
    default:
    {
        BITPIT_UNREACHABLE("This action is not handled");
        break;
    }
 
    }
 
    // Return the iterator to the position where the element was inserted
    return PiercedVectorStorage<value_t, id_t>::rawFind(pos);
}

template<typename value_t, typename id_t>
template<typename... Args, typename PiercedStorage<value_t, id_t>::template EnableIfHasInitialize<Args...> * >
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::emreclaimValue(const FillAction &action, Args&&... args)
{
    std::size_t pos = action.info[PiercedSyncAction::INFO_POS];
    switch (static_cast<typename FillAction::FillActionType>(action.type)) {
 
    case FillAction::TYPE_OVERWRITE:
    {
        PiercedVectorStorage<value_t, id_t>::rawInitialize(pos, std::forward<Args>(args)...);
        break;
    }
 
    case FillAction::TYPE_INSERT:
    {
        // Since we are increasing the sotrage by an element at the time
        // calling a reserve will hurt performance badly because this will
        // prevent the automatic reallocation of the storage.
        PiercedVectorStorage<value_t, id_t>::rawEmplace(pos, std::forward<Args>(args)...);
        break;
    }
 
    case FillAction::TYPE_APPEND:
    {
        // Since we are increasing the sotrage by an element at the time
        // calling a reserve will hurt performance badly because this will
        // prevent the automatic reallocation of the storage.
        PiercedVectorStorage<value_t, id_t>::rawEmplaceBack(std::forward<Args>(args)...);
        pos = PiercedVectorKernel<id_t>::getLastUsedPos();
        break;
    }
 
    default:
    {
        BITPIT_UNREACHABLE("This action is not handled");
        break;
    }
 
    }
 
    // Return the iterator to the position where the element was inserted
    return PiercedVectorStorage<value_t, id_t>::rawFind(pos);
}

template<typename value_t, typename id_t>
template<typename... Args>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::emplaceValue(const FillAction &action, Args&&... args)
{
    std::size_t pos = action.info[PiercedSyncAction::INFO_POS];
    switch (static_cast<typename FillAction::FillActionType>(action.type)) {
 
    case FillAction::TYPE_OVERWRITE:
    {
        PiercedVectorStorage<value_t, id_t>::rawEmreplace(pos, std::forward<Args>(args)...);
        break;
    }
 
    case FillAction::TYPE_INSERT:
    {
        // Since we are increasing the sotrage by an element at the time
        // calling a reserve will hurt performance badly because this will
        // prevent the automatic reallocation of the storage.
        PiercedVectorStorage<value_t, id_t>::rawEmplace(pos, std::forward<Args>(args)...);
        break;
    }
 
    case FillAction::TYPE_APPEND:
    {
        // Since we are increasing the sotrage by an element at the time
        // calling a reserve will hurt performance badly because this will
        // prevent the automatic reallocation of the storage.
        PiercedVectorStorage<value_t, id_t>::rawEmplaceBack(std::forward<Args>(args)...);
        pos = PiercedVectorKernel<id_t>::getLastUsedPos();
        break;
    }
 
    default:
    {
        BITPIT_UNREACHABLE("This action is not handled");
        break;
    }
 
    }
 
    // Return the iterator to the position where the element was inserted
    return PiercedVectorStorage<value_t, id_t>::rawFind(pos);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::moveValue(const MoveAction &action)
{
    std::size_t posNew = action.info[PiercedSyncAction::INFO_POS_FIRST];
    std::size_t posOld = action.info[PiercedSyncAction::INFO_POS_SECOND];
    switch (static_cast<typename MoveAction::MoveActionType>(action.type)) {
 
    case MoveAction::TYPE_OVERWRITE:
    {
        PiercedVectorStorage<value_t, id_t>::rawSet(posNew, std::move(PiercedVectorStorage<value_t, id_t>::rawAt(posOld)));
        break;
    }
 
    case MoveAction::TYPE_INSERT:
    {
        // Since we are increasing the sotrage by an element at the time
        // calling a reserve will hurt performance badly because this will
        // prevent the automatic reallocation of the storage.
        PiercedVectorStorage<value_t, id_t>::rawInsert(posNew, 1, std::move(PiercedVectorStorage<value_t, id_t>::rawAt(posOld)));
        break;
    }
 
    case MoveAction::TYPE_APPEND:
    {
        // Since we are increasing the sotrage by an element at the time
        // calling a reserve will hurt performance badly because this will
        // prevent the automatic reallocation of the storage.
        PiercedVectorStorage<value_t, id_t>::rawPushBack(std::move(PiercedVectorStorage<value_t, id_t>::rawAt(posOld)));
        posNew = PiercedVectorKernel<id_t>::getLastUsedPos();
        break;
    }
 
    default:
    {
        BITPIT_UNREACHABLE("This action is not handled");
        break;
    }
 
    }
 
    // Clear the old position
    PiercedVectorStorage<value_t, id_t>::rawEmreplace(posOld);
 
    // Return the iterator to the new position
    return PiercedVectorStorage<value_t, id_t>::rawFind(posNew);
}

template<typename value_t, typename id_t>
typename PiercedVector<value_t, id_t>::iterator PiercedVector<value_t, id_t>::eraseValue(const EraseAction &action)
{
    switch (static_cast<typename EraseAction::EraseActionType>(action.type)) {
 
    case EraseAction::TYPE_PIERCE:
    {
        // Nothing to do. To improve performance the element will not be
        // cleared.
        break;
    }
 
    case EraseAction::TYPE_SHRINK:
    {
        std::size_t rawSize = action.info[PiercedSyncAction::INFO_SIZE];
        PiercedVectorStorage<value_t, id_t>::rawResize(rawSize);
        break;
    }
 
    default:
    {
        BITPIT_UNREACHABLE("This action is not handled");
        break;
    }
 
    }
 
    // Return the iterator to the next element
    std::size_t nextPos = action.info[PiercedSyncAction::INFO_POS_NEXT];
 
    return PiercedVectorStorage<value_t, id_t>::rawFind(nextPos);
}

template<typename value_t, typename id_t>
void PiercedVector<value_t, id_t>::swapValues(const SwapAction &action)
{
    switch (static_cast<typename SwapAction::SwapActionType>(action.type)) {
 
    case SwapAction::TYPE_SWAP:
    {
        std::size_t posFirst  = action.info[PiercedSyncAction::INFO_POS_FIRST];
        std::size_t posSecond = action.info[PiercedSyncAction::INFO_POS_SECOND];
        PiercedVectorStorage<value_t, id_t>::rawSwap(posFirst, posSecond);
        break;
    }
 
    default:
    {
        BITPIT_UNREACHABLE("This action is not handled");
        break;
    }
 
    }
}
 
}
 
#endif