piercedKernelRange.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_KERNEL_RANGE_TPP__
#define __BITPIT_PIERCED_KERNEL_RANGE_TPP__
 
namespace bitpit {
 
template<typename id_t>
PiercedKernelRange<id_t>::PiercedKernelRange()
    : m_cbegin(),
      m_cend()
{
}
 
template<typename id_t>
PiercedKernelRange<id_t>::PiercedKernelRange(const kernel_t *kernel)
{
    initialize(kernel);
}
 
template<typename id_t>
PiercedKernelRange<id_t>::PiercedKernelRange(const kernel_t *kernel, id_t first, id_t last)
{
    initialize(kernel, first, last);
}
 
template<typename id_t>
PiercedKernelRange<id_t>::PiercedKernelRange(const const_iterator &begin, const const_iterator &end)
{
    initialize(begin, end);
}
 
template<typename id_t>
void PiercedKernelRange<id_t>::initialize(const kernel_t *kernel)
{
    m_cbegin = kernel->cbegin();
    m_cend   = kernel->cend();
}
 
template<typename id_t>
void PiercedKernelRange<id_t>::initialize(const kernel_t *kernel, id_t first, id_t last)
{
    m_cbegin = kernel->find(first);
    m_cend   = ++(kernel->find(last));
}
 
template<typename id_t>
void PiercedKernelRange<id_t>::initialize(const const_iterator &begin, const const_iterator &end)
{
    if (&(begin.getKernel()) != &(end.getKernel())) {
        throw std::runtime_error("The two iterators belong to different kernels");
    }
 
    m_cbegin = begin;
    m_cend   = end;
}
 
template<typename id_t>
void PiercedKernelRange<id_t>::swap(PiercedKernelRange &other) noexcept
{
    std::swap(m_cbegin, other.m_cbegin);
    std::swap(m_cend, other.m_cend);
}
 
template<typename id_t>
std::size_t PiercedKernelRange<id_t>::evalSize() const
{
    const PiercedKernel<id_t> &kernel = m_cbegin.getKernel();
 
    std::size_t flatBegin = kernel.evalFlatIndex(m_cbegin.getId());
 
    std::size_t flatEnd;
    if (m_cend.getPos() <= kernel.getLastUsedPos()) {
        flatEnd = kernel.evalFlatIndex(m_cend.getId()) + 1;
    } else {
        flatEnd = kernel.size();
    }
 
    std::size_t size = (flatEnd - flatBegin);
 
    return size;
}
 
template<typename id_t>
typename PiercedKernelRange<id_t>::const_iterator PiercedKernelRange<id_t>::begin() const noexcept
{
    return m_cbegin;
}
 
template<typename id_t>
typename PiercedKernelRange<id_t>::const_iterator PiercedKernelRange<id_t>::end() const noexcept
{
    return m_cend;
}
 
template<typename id_t>
typename PiercedKernelRange<id_t>::const_iterator PiercedKernelRange<id_t>::cbegin() const noexcept
{
    return m_cbegin;
}
 
template<typename id_t>
typename PiercedKernelRange<id_t>::const_iterator PiercedKernelRange<id_t>::cend() const noexcept
{
    return m_cend;
}
 
}
 
#endif