IteratorUtil.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3cpp iterator_util.h
 
#pragma once
#include "IndexTypes.h"
#include "Templates/Function.h"
 
namespace UE
{
namespace Geometry
{
 
 
template<typename FromType, typename ToType, typename IteratorT>
class MappedIterator
{
    using MapFunctionT = TFunction<ToType(FromType)>;
 
public:
    inline MappedIterator() { }
 
    inline bool operator==(const MappedIterator& Other) const
    {
        return Cur == Other.Cur;
    }
    inline bool operator!=(const MappedIterator& Other) const 
    {
        return Cur != Other.Cur;
    }
 
    inline ToType operator*() const 
    {
        return MapFunction(*Cur);
    }
 
    inline const MappedIterator& operator++()       // prefix
    {
        Cur++;
        return *this;
    }
 
    inline MappedIterator(const IteratorT& CurItr, const MapFunctionT& MapFunctionIn)
    {
        Cur = CurItr;
        MapFunction = MapFunctionIn;
    }
 
    IteratorT Cur;
    MapFunctionT MapFunction;
};
 
 
 
 
 
 
 
template<typename ValueType, typename IteratorT>
class FilteredIterator
{
    using FilterFunctionT = TFunction<bool(ValueType)>;
 
public:
    inline FilteredIterator() { }
 
    inline bool operator==(const FilteredIterator& Other) const 
    {
        return Cur == Other.Cur;
    }
    inline bool operator!=(const FilteredIterator& Other) const
    {
        return Cur != Other.Cur;
    }
 
    inline ValueType operator*() const 
    {
        return *Cur;
    }
 
    inline const FilteredIterator& operator++()         // prefix
    {
        GotoNextElement();
        return *this;
    }
 
    inline void GotoNextElement() 
    {
        do {
            Cur++;
        } while (Cur != End && FilterFunc(*Cur) == false);
    }
 
    inline FilteredIterator(const IteratorT& CurItr, const IteratorT& EndItr, const FilterFunctionT& FilterFuncIn)
    {
        Cur = CurItr;
        End = EndItr;
        this->FilterFunc = FilterFuncIn;
        if (Cur != End && FilterFunc(*Cur) == false)
        {
            GotoNextElement();
        }
    }
 
    IteratorT Cur;
    IteratorT End;
    FilterFunctionT FilterFunc;
};
 
 
 
 
 
 
 
 
 
 
template<typename OutputType, typename InputType, typename InputIteratorT>
class ExpandIterator
{
    using ExpandFunctionT = TFunction<OutputType(InputType, int&)>;
 
public:
    inline ExpandIterator() { }
 
    inline bool operator==(const ExpandIterator& Other) const 
    {
        return Cur == Other.Cur;
    }
    inline bool operator!=(const ExpandIterator & Other) const 
    {
        return Cur != Other.Cur;
    }
 
    inline OutputType operator*() const 
    {
        return CurValue;
    }
 
    inline const ExpandIterator& operator++()       // prefix
    {
        goto_next();
        return *this;
    }
 
    inline void goto_next() 
    {
        while (Cur != End) 
        {
            CurValue = ExpandFunc(*Cur, CurExpandI);
            if (CurExpandI == -1)
            {
                ++Cur;  // done with this base value
            }
            else
            {
                break; // want caller to see current output value
            }
        }
    }
 
    inline ExpandIterator(const InputIteratorT& CurItr, const InputIteratorT& EndItr, const ExpandFunctionT& ExpandFuncIn)
    {
        Cur = CurItr;
        End = EndItr;
        ExpandFunc = ExpandFuncIn;
        CurExpandI = -1;
        goto_next();
    }
 
    InputIteratorT Cur;
    InputIteratorT End;
    OutputType CurValue;
    int CurExpandI;
    ExpandFunctionT ExpandFunc;
};
 
 
 
template<typename OutputType, typename InputType, typename InputIteratorT>
class ExpandEnumerable
{
    using ExpandFunctionT = TFunction<OutputType(InputType, int&)>;
    using ExpandIteratorT = ExpandIterator<OutputType, InputType, InputIteratorT>;
 
public:
    ExpandFunctionT ExpandFunc;
    InputIteratorT BeginItr, EndItr;
 
    ExpandEnumerable(const InputIteratorT& BeginIn, const InputIteratorT& EndIn, ExpandFunctionT ExpandFuncIn) 
    {
        this->BeginItr = BeginIn;
        this->EndItr = EndIn;
        this->ExpandFunc = ExpandFuncIn;
    }
 
    template<typename IteratorSource>
    ExpandEnumerable(const IteratorSource& Source, ExpandFunctionT ExpandFuncIn)
    {
        this->BeginItr = Source.begin();
        this->EndItr = Source.end();
        this->ExpandFunc = ExpandFuncIn;
    }
 
    ExpandIteratorT begin() 
    {
        return ExpandIteratorT(BeginItr, EndItr, ExpandFunc);
    }
 
    ExpandIteratorT end()
    {
        return ExpandIteratorT(EndItr, EndItr, ExpandFunc);
    }
};
 
 
 
 
 
 
 
 
 
 
 
 
template<typename InputIteratorT>
class TPairExpandIterator
{
    using PairExpandFunctionT = TFunction<FIndex2i(int)>;
 
public:
    inline TPairExpandIterator() { }
 
    inline bool operator==(const TPairExpandIterator& Other) const
    {
        return Cur == Other.Cur;
    }
    inline bool operator!=(const TPairExpandIterator & Other) const
    {
        return Cur != Other.Cur;
    }
 
    inline int operator*() const
    {
        return CurValue;
    }
 
    inline const TPairExpandIterator& operator++()      // prefix
    {
        goto_next();
        return *this;
    }
 
    inline void goto_next()
    {
        while (Cur != End)
        {
            if (CurPairI == 0)
            {
                CurPair = PairFunc(*Cur);
                if (CurPair.A >= 0)
                {
                    CurValue = CurPair.A;
                    CurPairI = 1;   // want to take second branch
                    return;         // let caller see value
                }
                else
                {
                    CurPairI = 0;
                    ++Cur;  // done with this base value
                }
            }
            else if (CurPairI == 1)
            {
                if (CurPair.B >= 0)
                {
                    CurValue = CurPair.B;
                    CurPairI = 2;   // want to take third branch
                    return;     // let caller see value
                }
                else
                {
                    CurPairI = 0;
                    ++Cur;  // done with this base value
                }
            }
            else
            {
                CurPairI = 0;
                ++Cur;  // done with this base value
            }
        }
    }
 
    inline TPairExpandIterator(const InputIteratorT& CurItr, const InputIteratorT& EndItr, const PairExpandFunctionT& PairFuncIn)
    {
        Cur = CurItr;
        End = EndItr;
        PairFunc = PairFuncIn;
        CurPairI = 0;
        goto_next();
    }
 
    InputIteratorT Cur;
    InputIteratorT End;
    FIndex2i CurPair;
    int CurValue;
    int CurPairI;
    PairExpandFunctionT PairFunc;
};
 
 
 
 
template<typename InputIteratorT>
class TPairExpandEnumerable
{
    using ExpandFunctionT = TFunction<FIndex2i(int)>;
    using ExpandIteratorT = TPairExpandIterator<InputIteratorT>;
 
public:
    ExpandFunctionT ExpandFunc;
    InputIteratorT BeginItr, EndItr;
 
    TPairExpandEnumerable(const InputIteratorT& BeginIn, const InputIteratorT& EndIn, ExpandFunctionT ExpandFuncIn)
    {
        this->BeginItr = BeginIn;
        this->EndItr = EndIn;
        this->ExpandFunc = ExpandFuncIn;
    }
 
    template<typename IteratorSource>
    TPairExpandEnumerable(const IteratorSource& Source, ExpandFunctionT ExpandFuncIn)
    {
        this->BeginItr = Source.begin();
        this->EndItr = Source.end();
        this->ExpandFunc = ExpandFuncIn;
    }
 
    ExpandIteratorT begin()
    {
        return ExpandIteratorT(BeginItr, EndItr, ExpandFunc);
    }
 
    ExpandIteratorT end()
    {
        return ExpandIteratorT(EndItr, EndItr, ExpandFunc);
    }
};
 
 
 
struct FModuloIteration
{
    uint64 MaxIndex = 0;
    uint64 ModuloPrime = 4294967311ull;     // prime > max_unsigned_int
    uint64 CurIndex = 0;
    uint64 StartIndex = 0;
    uint64 Count = 0;
    uint64 ModuloNum = 1;
 
    FModuloIteration(uint32 MaxIndexIn, uint32 StartIndexIn = 0, uint64 ModuloPrimeIn = 3208642561)
    {
        MaxIndex = (uint64)FMath::Max((uint32)0, MaxIndexIn);
        StartIndex = (uint64)FMath::Max((uint32)0, StartIndexIn);
        CurIndex = 0;
        Count = 0;
        ModuloNum = FMath::Max((uint64)1, MaxIndex);  // can't be zero or we hit integer-divide. If MaxIndex is 0 we will terminate on first iteration anyway
        ModuloPrime = ModuloPrimeIn;
        check(ModuloPrime > MaxIndex);
    }
 
    bool GetNextIndex(uint32& NextIndexOut)
    {
        NextIndexOut = (uint32)CurIndex;
        CurIndex = (CurIndex + ModuloPrime) % ModuloNum;
        return (Count++ != MaxIndex);
    }
 
    bool GetNextIndex(int32& NextIndexOut)
    {
        NextIndexOut = (int32)CurIndex;
        CurIndex = (CurIndex + ModuloPrime) % ModuloNum;
        return (Count++ != MaxIndex);
    }
};
 
 
 
} // end namespace UE::Geometry
} // end namespace UE