/src/libreoffice/include/basegfx/range/basicrange.hxx

Source
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#pragma once

#include <sal/types.h>
#include <float.h>
#include <basegfx/numeric/ftools.hxx>


namespace basegfx
{
    template< typename T, typename Traits > class BasicRange
    {
    protected:
        T mnMinimum;
        T mnMaximum;

    public:
        typedef T       ValueType;
        typedef Traits  TraitsType;

        BasicRange() :
            mnMinimum(Traits::maxVal()),
            mnMaximum(Traits::minVal())
        {
        }

        explicit BasicRange( T nValue ) :
            mnMinimum(nValue),
            mnMaximum(nValue)
        {
        }

        void reset()
        {
            mnMinimum = Traits::maxVal();
            mnMaximum = Traits::minVal();
        }

        bool isEmpty() const
        {
            return Traits::maxVal() == mnMinimum;
        }

        T getMinimum() const { return mnMinimum; }
        T getMaximum() const { return mnMaximum; }

        double getCenter() const
        {
            if(isEmpty())
            {
                return 0.0;
            }
            else
            {
                return ((mnMaximum + mnMinimum) / 2.0);
            }
        }

        bool isInside(T nValue) const
        {
            if(isEmpty())
            {
                return false;
            }
            else
            {
                return (nValue >= mnMinimum) && (nValue <= mnMaximum);
            }
        }

        bool isInside(const BasicRange& rRange) const
        {
            if(isEmpty())
            {
                return false;
            }
            else
            {
                if(rRange.isEmpty())
                {
                    return false;
                }
                else
                {
                    return (rRange.mnMinimum >= mnMinimum) && (rRange.mnMaximum <= mnMaximum);
                }
            }
        }

        bool overlaps(const BasicRange& rRange) const
        {
            if(isEmpty())
            {
                return false;
            }
            else
            {
                if(rRange.isEmpty())
                {
                    return false;
                }
                else
                {
                    return (rRange.mnMaximum >= mnMinimum) && (rRange.mnMinimum <= mnMaximum);
                }
            }
        }

        bool overlapsMore(const BasicRange& rRange) const
        {
            if(isEmpty() || rRange.isEmpty())
                return false;
            // returns true if the overlap is more than just a touching at the limits
            return ((rRange.mnMaximum > mnMinimum) && (rRange.mnMinimum < mnMaximum));
        }

        bool operator==( const BasicRange& rRange ) const
        {
            return (mnMinimum == rRange.mnMinimum && mnMaximum == rRange.mnMaximum);
        }

        bool operator!=( const BasicRange& rRange ) const
        {
            return (mnMinimum != rRange.mnMinimum || mnMaximum != rRange.mnMaximum);
        }

        bool equal(const BasicRange& rRange) const
        {
            return (
                fTools::equal(mnMinimum, rRange.mnMinimum) &&
                fTools::equal(mnMaximum, rRange.mnMaximum));
        }

        /// true when both limits differ by fSmallValue or less
        bool equal(const BasicRange& rRange, T fSmallValue) const
        {
            return (
                fTools::equal(mnMinimum, rRange.mnMinimum, fSmallValue) &&
                fTools::equal(mnMaximum, rRange.mnMaximum, fSmallValue));
        }

        void expand(T nValue)
        {
            if(isEmpty())
            {
                mnMinimum = mnMaximum = nValue;
            }
            else
            {
// Silence over-eager warning emitted at least by GCC 4.9.2 in certain
// instantiations:
#if defined __GNUC__ && !defined __clang__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-overflow"
#endif
                if(nValue < mnMinimum)
#if defined __GNUC__ && !defined __clang__
#pragma GCC diagnostic pop
#endif
                {
                    mnMinimum = nValue;
                }

                if(nValue > mnMaximum)
                {
                    mnMaximum = nValue;
                }
            }
        }

        void expand(const BasicRange& rRange)
        {
            if(isEmpty())
            {
                mnMinimum = rRange.mnMinimum;
                mnMaximum = rRange.mnMaximum;
            }
            else
            {
                if(!rRange.isEmpty())
                {
                    if(rRange.mnMinimum < mnMinimum)
                    {
                        mnMinimum = rRange.mnMinimum;
                    }

                    if(rRange.mnMaximum > mnMaximum)
                    {
                        mnMaximum = rRange.mnMaximum;
                    }
                }
            }
        }

        void intersect(const BasicRange& rRange)
        {
            // here, overlaps also tests all isEmpty() conditions already.
            if( !overlaps( rRange ) )
            {
                reset();
            }
            else
            {
                if(rRange.mnMinimum > mnMinimum)
                {
                    mnMinimum = rRange.mnMinimum;
                }

                if(rRange.mnMaximum < mnMaximum)
                {
                    mnMaximum = rRange.mnMaximum;
                }
            }
        }

        void grow(T nValue)
        {
            if(isEmpty())
                return;

            bool bLessThanZero(nValue < 0);

            if(nValue > 0 || bLessThanZero)
            {
                mnMinimum -= nValue;
                mnMaximum += nValue;

                if(bLessThanZero)
                {
                    // test if range did collapse
                    if(mnMinimum > mnMaximum)
                    {
                        // if yes, collapse to center
                        mnMinimum = mnMaximum = (mnMinimum + mnMaximum) / 2;
                    }
                }
            }
        }

        T clamp(T nValue) const
        {
            if(isEmpty())
            {
                return nValue;
            }
            else
            {
                if(nValue < mnMinimum)
                {
                    return mnMinimum;
                }

                if(nValue > mnMaximum)
                {
                    return mnMaximum;
                }

                return nValue;
            }
        }

#if defined _MSC_VER && defined(_M_ARM64)
#pragma warning(push)
#pragma warning(disable: 4723) /* ignore: warning for (C4723) potential divide by 0 on windows arm64 build */
#endif
        typename Traits::DifferenceType getRange() const
        {
            if(isEmpty())
            {
                return Traits::neutral();
            }
            else
            {
                return (mnMaximum - mnMinimum);
            }
        }
#if defined _MSC_VER && defined(_M_ARM64)
#pragma warning( pop )
#endif
    };

    // some pre-fabricated traits
    struct DoubleTraits
    {
        static constexpr double minVal() { return DBL_MIN; };
        static constexpr double maxVal() { return DBL_MAX; };
        static constexpr double neutral() { return 0.0; };

        typedef double DifferenceType;
    };

    struct Int32Traits
    {
        static constexpr sal_Int32 minVal() { return SAL_MIN_INT32; };
        static constexpr sal_Int32 maxVal() { return SAL_MAX_INT32; };
        static constexpr sal_Int32 neutral() { return 0; };

        typedef sal_Int64 DifferenceType;
    };

} // end of namespace basegfx

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Coverage Report

Created: 2026-11-06 11:29