Intervals.h

// SPDX-FileCopyrightText: 2023 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <limits>
 
namespace imgdoc2
{
    struct DoubleInterval
    {
        double minimum_value{ std::numeric_limits<double>::max() };  
        double maximum_value{ std::numeric_limits<double>::lowest() };  
 
        [[nodiscard]] bool IsValid() const
        {
            return this->minimum_value <= this->maximum_value;
        }
 
        [[nodiscard]] bool operator==(const DoubleInterval& rhs) const
        {
            if (this->minimum_value == rhs.minimum_value && this->maximum_value == rhs.maximum_value)
            {
                return true;
            }
 
            // if both are invalid, then we consider them as equal - otherwise, they are unequal
            return !this->IsValid() && !rhs.IsValid();
        }
 
        [[nodiscard]] bool operator!=(const DoubleInterval& rhs) const
        {
            return !(*this == rhs);
        }
    };
 
    struct Int32Interval
    {
        std::int32_t minimum_value{ std::numeric_limits<std::int32_t>::max() };  
        std::int32_t maximum_value{ std::numeric_limits<std::int32_t>::min() };  
 
        [[nodiscard]] bool IsValid() const
        {
            return this->minimum_value <= this->maximum_value;
        }
 
        bool operator==(const Int32Interval& rhs) const
        {
            if (this->minimum_value == rhs.minimum_value && this->maximum_value == rhs.maximum_value)
            {
                return true;
            }
 
            // if both are invalid, then we consider them as equal - otherwise, they are unequal
            return !this->IsValid() && !rhs.IsValid();
        }
 
        bool operator!=(const Int32Interval& rhs) const
        {
            return !(*this == rhs);
        }
    };
}  // namespace imgdoc2