ITileCoordinate.h

// SPDX-FileCopyrightText: 2023 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <functional>
#include <vector>
#include "types.h"
 
namespace imgdoc2
{
    class ITileCoordinate
    {
    public:
        virtual bool TryGetCoordinate(imgdoc2::Dimension dim, int* coordVal) const = 0;
 
        virtual void EnumCoordinates(const std::function<bool(imgdoc2::Dimension, int)>& f) const = 0;
 
        virtual ~ITileCoordinate() = default;
 
        inline void EnumDimensions(const std::function<bool(imgdoc2::Dimension)>& f) const
        {
            this->EnumCoordinates([&](imgdoc2::Dimension d, int v)->bool {return f(d); });
        }
 
        [[nodiscard]] static bool AreEqual(const ITileCoordinate* a, const ITileCoordinate* b)
        {
            if (a == nullptr || b == nullptr)
            {
                return false;
            }
 
            if (a == b)
            {
                return true;
            }
 
            bool are_equal = true;
 
            // first, we enumerate the dimensions in a and check if they are also in b (and have the same value)
            a->EnumCoordinates(
                [=, &are_equal](imgdoc2::Dimension dimension, int value_a)->bool
                {
                    int value_b;
                    if (!b->TryGetCoordinate(dimension, &value_b))
                    {
                        are_equal = false;
                        return false;
                    }
 
                    if (value_a != value_b)
                    {
                        are_equal = false;
                        return false;
                    }
 
                    return true;
                });
 
            if (are_equal)
            {
                // Ok, this means that for all dimensions present in a, we have the same value in b (and dimension is also present in b of course).
                // However, it may be that b has more dimensions than a. So we need to check that as well (but we don't need to check the equality
                // of the values anymore this time).
                b->EnumCoordinates(
                   [=, &are_equal](imgdoc2::Dimension dimension, int)->bool
                   {
                       if (!a->TryGetCoordinate(dimension, nullptr))
                       {
                           are_equal = false;
                           return false;
                       }
 
                       return true;
                   });
            }
 
            return are_equal;
        }
 
        bool operator==(const ITileCoordinate& other) const
        {
            return ITileCoordinate::AreEqual(this, &other);
        }
 
        bool operator!=(const ITileCoordinate& other) const
        {
            return !ITileCoordinate::AreEqual(this, &other);
        }
 
        [[nodiscard]] std::vector<imgdoc2::Dimension> GetDimensions() const
        {
            std::vector<imgdoc2::Dimension> vec;
            this->EnumDimensions(
                [&vec](imgdoc2::Dimension d)->bool
                {
                    vec.push_back(d);
                    return true;
                });
 
            return vec;
        }
 
        [[nodiscard]] inline static bool IsValidDimension(imgdoc2::Dimension dimension)
        {
            return imgdoc2::IsDimensionValid(dimension);
        }
    };
 
    class ITileCoordinateMutate : public ITileCoordinate
    {
    public:
        virtual void Clear() = 0;
 
        virtual void Set(imgdoc2::Dimension d, int value) = 0;
 
        ~ITileCoordinateMutate() override = default;
    };
}