Range.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way  
 * Copyright Raphael Stoeckli © 2025
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using System.Collections.Generic;
 
namespace NanoXLSX
{
    public struct Range
    {
        private readonly Address startAddress;
        private readonly Address endAddress;

        public Address EndAddress { get => endAddress; }
        public Address StartAddress { get => startAddress; }

        public Range(Address start, Address end)
        {
            if (start.CompareTo(end) < 0)
            {
                this.startAddress = start;
                this.endAddress = end;
            }
            else
            {
                this.startAddress = end;
                this.endAddress = start;
            }
        }

        public Range(int startColumn, int startRow, int endColumn, int endRow) : this(new Address(startColumn, startRow), new Address(endColumn, endRow))
        {
        }
 

        public Range(string range)
        {
            Range r = Cell.ResolveCellRange(range);
            if (r.StartAddress.CompareTo(r.EndAddress) < 0)
            {
                this.startAddress = r.StartAddress;
                this.endAddress = r.EndAddress;
            }
            else
            {
                this.startAddress = r.EndAddress;
                this.endAddress = r.StartAddress;
            }
        }

        public bool Contains(Range other)
        {
            return this.StartAddress.Column <= other.StartAddress.Column &&
                   this.EndAddress.Column >= other.EndAddress.Column &&
                   this.StartAddress.Row <= other.StartAddress.Row &&
                   this.EndAddress.Row >= other.EndAddress.Row;
        }

        public bool Contains(Address address)
        {
            return address.Column >= this.startAddress.Column &&
                address.Column <= this.endAddress.Column &&
                address.Row >= this.startAddress.Row &&
                address.Row <= this.endAddress.Row;
        }

        public bool Overlaps(Range other)
        {
            return !(this.EndAddress.Row < other.StartAddress.Row || this.StartAddress.Row > other.EndAddress.Row ||
                     this.EndAddress.Column < other.StartAddress.Column || this.StartAddress.Column > other.EndAddress.Column);
        }
 

        public IReadOnlyList<Address> ResolveEnclosedAddresses()
        {
            IEnumerable<Address> range = Cell.GetCellRange(this.StartAddress, this.EndAddress);
            return new List<Address>(range);
        }
 

        public override string ToString()
        {
            return StartAddress + ":" + EndAddress;
        }

        public override bool Equals(object obj)
        {
            if (!(obj is Range))
            {
                return false;
            }
            Range other = (Range)obj;
            return this.StartAddress.Equals(other.StartAddress) && this.EndAddress.Equals(other.EndAddress);
        }

        public override int GetHashCode()
        {
            return this.ToString().GetHashCode();
        }
 
        // Operator overloads
 
        // Operator overloads
        public static bool operator ==(Range range1, Range range2)
        {
            return range1.Equals(range2);
        }

        public static bool operator !=(Range range1, Range range2)
        {
            return !range1.Equals(range2);
        }
 

        internal Range Copy()
        {
            return new Range(this.StartAddress.Copy(), this.EndAddress.Copy());
        }
 
    }
 
}