Mismatch.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Templates/EqualTo.h"
#include "Templates/IdentityFunctor.h"
#include "Templates/Invoke.h"
#include "Templates/UnrealTemplate.h"
 
#include <type_traits>
 
namespace Algo::Private
{
    template <typename InputAType, typename InputBType, typename ProjectionType, typename PredicateType>
    constexpr auto Mismatch(const InputAType& InputA, const InputBType& InputB, ProjectionType Projection, PredicateType Predicate)
    {
        using IndexType = std::common_type_t<decltype(GetNum(InputA)), decltype(GetNum(InputB))>;
 
        IndexType Index = 0;
 
        const IndexType SizeA = (IndexType)GetNum(InputA);
        const IndexType SizeB = (IndexType)GetNum(InputB);
 
        auto* A = GetData(InputA);
        auto* B = GetData(InputB);
 
        for (;;)
        {
            if (Index == SizeA || Index == SizeB)
            {
                break;
            }
 
            if (!Invoke(Predicate, Invoke(Projection, *A++), Invoke(Projection, *B++)))
            {
                break;
            }
 
            ++Index;
        }
 
        return Index;
    }
}
 
namespace Algo
{
    template <typename InputAType, typename InputBType>
    [[nodiscard]] constexpr auto Mismatch(const InputAType& InputA, const InputBType& InputB) -> std::common_type_t<decltype(GetNum(InputA)), decltype(GetNum(InputB))>
    {
        return Private::Mismatch(InputA, InputB, FIdentityFunctor(), TEqualTo<>());
    }
 
    template <typename InputAType, typename InputBType, typename PredicateType>
    [[nodiscard]] constexpr auto Mismatch(const InputAType& InputA, const InputBType& InputB, PredicateType Predicate) -> std::common_type_t<decltype(GetNum(InputA)), decltype(GetNum(InputB))>
    {
        return Private::Mismatch(InputA, InputB, FIdentityFunctor(), MoveTemp(Predicate));
    }
 
    template <typename InputAType, typename InputBType, typename ProjectionType>
    [[nodiscard]] constexpr auto MismatchBy(const InputAType& InputA, const InputBType& InputB, ProjectionType Projection) -> std::common_type_t<decltype(GetNum(InputA)), decltype(GetNum(InputB))>
    {
        return Private::Mismatch(InputA, InputB, MoveTemp(Projection), TEqualTo<>());
    }
 
    template <typename InputAType, typename InputBType, typename ProjectionType, typename PredicateType>
    [[nodiscard]] constexpr auto MismatchBy(const InputAType& InputA, const InputBType& InputB, ProjectionType Projection, PredicateType Predicate) -> std::common_type_t<decltype(GetNum(InputA)), decltype(GetNum(InputB))>
    {
        return Private::Mismatch(InputA, InputB, MoveTemp(Projection), MoveTemp(Predicate));
    }
}