LayerListIterators.h

Go to the documentation of this file.

/*
* SPDX-FileCopyrightText: Copyright (c) 2020-2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
 
 
#ifndef NVNEURAL_LAYERLISTITERATORS_H
#define NVNEURAL_LAYERLISTITERATORS_H
 
#include <nvneural/CoreTypes.h>
 
#include <iterator>
 
namespace nvneural {
 
class LayerListIterator
{
public:
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = ILayer*;
    using pointer = ILayer* const*;
    using reference = ILayer* const&;
 
    LayerListIterator(const ILayerList* pLayerList, size_t index)
        : m_pLayerList(pLayerList)
        , m_index(index)
    {
    }
 
    LayerListIterator(RefPtr<ILayerList>& pLayerList, size_t index)
        : m_pLayerList(pLayerList.get())
        , m_index(index)
    {
    }
 
    ILayer* operator *() const noexcept
    {
        return m_pLayerList->getLayerByIndex(m_index);
    }
 
    LayerListIterator& operator ++() noexcept
    {
        ++m_index;
        return *this;
    }
 
    LayerListIterator operator ++(int) noexcept
    {
        LayerListIterator oldMe = *this;
        ++*this;
        return oldMe;
    }
 
    bool operator !=(const LayerListIterator& other) const noexcept
    {
        const bool samePointer = m_pLayerList == other.m_pLayerList;
        const bool sameIndex = m_index == other.m_index;
        return !(samePointer && sameIndex);
    }
 
private:
    const ILayerList* const m_pLayerList;
    size_t m_index;
};
 
inline LayerListIterator begin(const ILayerList* pLayerList) noexcept
{
    return LayerListIterator(pLayerList, 0);
}
 
inline LayerListIterator begin(const RefPtr<ILayerList>& pLayerList) noexcept
{
    return LayerListIterator(pLayerList.get(), 0);
}
 
inline LayerListIterator end(const ILayerList* pLayerList) noexcept
{
    return LayerListIterator(pLayerList, pLayerList->layerCount());
}
 
inline LayerListIterator end(const RefPtr<ILayerList>& pLayerList) noexcept
{
    return LayerListIterator(pLayerList.get(), pLayerList->layerCount());
}
 
} // namespace nvneural
 
#endif // NVNEURAL_LAYERLISTITERATORS_H