FormulaData.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 © 2026
 * 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;
using System.Collections.Generic;
using NanoXLSX.Enums;
using NanoXLSX.Internal;
using NanoXLSX.Utils;
 
namespace NanoXLSX
{
    public class FormulaData : IEquatable<FormulaData>, IComparable<FormulaData>
    {
        private string expression;
 
        #region enums
        public enum FormulaType
        {
            Normal,
            Array,
            Shared,
            DataTable
        }
        #endregion
 
        private bool hasExternalReferences;
        private DefinedName definedNameReference;
 
        #region properties

        public string Expression
        {
            get { return expression; }
            internal set
            {
                expression = value;
                HasExternalReferences = ParserUtils.ContainsExternalReference(value);
            }
        }

        public bool HasExternalReferences
        {
            get { return hasExternalReferences; }
            internal set
            {
                hasExternalReferences = value;
                Features.SetFormulaFeatures(definedNameReference == null ? false : true, hasExternalReferences);
            }
        }

        public FormulaType Type { get; internal set; }

        public string FormulaRange { get; internal set; }

        public DefinedName DefinedNameReference
        {
            get { return definedNameReference; }
            internal set
            {
                definedNameReference = value;
                Features.SetFormulaFeatures(definedNameReference == null ? false : true, hasExternalReferences);
            }
        }

        public object CachedValue { get; internal set; }

        public Cell.CellType CachedValueType { get; internal set; }

        public string MasterCellAddress { get; internal set; }

        internal FeatureSet Features { get; private set; } = FeatureSet.CreateFormula();
 
        #endregion
 
        #region constructors

        public FormulaData()
        {
            this.Type = FormulaType.Normal;
            this.CachedValueType = Cell.CellType.Default;
        }

        public FormulaData(string expression, object cachedValue = null) : this()
        {
            Expression = expression;
            CachedValue = cachedValue;
            CachedValueType = ResolveCachedValueType(cachedValue);
        }
 
        #endregion
        #region methods

        internal static Cell.CellType ResolveCachedValueType(object cachedValue)
        {
            if (cachedValue == null)
            {
                return Cell.CellType.Default;
            }
            if (cachedValue is bool)
            {
                return Cell.CellType.Bool;
            }
            if (cachedValue is byte || cachedValue is sbyte || cachedValue is decimal || cachedValue is double
                || cachedValue is float || cachedValue is int || cachedValue is uint || cachedValue is long
                || cachedValue is ulong || cachedValue is short || cachedValue is ushort)
            {
                return Cell.CellType.Number;
            }
            if (cachedValue is DateTime)
            {
                return Cell.CellType.Date;
            }
            if (cachedValue is TimeSpan)
            {
                return Cell.CellType.Time;
            }
            if (cachedValue is Errors.FormulaError)
            {
                return Cell.CellType.Error;
            }
            return Cell.CellType.String;
        }

        internal FormulaData Copy()
        {
            FormulaData data = new FormulaData();
            data.Expression = this.Expression;
            data.Type = this.Type;
            data.FormulaRange = this.FormulaRange;
            data.CachedValue = this.CachedValue;
            data.CachedValueType = this.CachedValueType;
            data.MasterCellAddress = this.MasterCellAddress;
            data.Features = this.Features.Copy(); // New feature set
            data.DefinedNameReference = this.DefinedNameReference; // object reference
            return data;
        }

        public int CompareTo(FormulaData other)
        {
            if (other is null)
            {
                return 1;
            }
            int cmp = string.CompareOrdinal(Expression, other.Expression);
            if (cmp != 0)
            {
                return cmp;
            }
            cmp = Type.CompareTo(other.Type);
            if (cmp != 0)
            {
                return cmp;
            }
            cmp = string.CompareOrdinal(FormulaRange, other.FormulaRange);
            if (cmp != 0)
            {
                return cmp;
            }
            cmp = Comparer<DefinedName>.Default.Compare(DefinedNameReference, other.DefinedNameReference);
            if (cmp != 0)
            {
                return cmp;
            }
            cmp = CachedValueType.CompareTo(other.CachedValueType);
            if (cmp != 0)
            {
                return cmp;
            }
            cmp = Comparer<object>.Default.Compare(CachedValue, other.CachedValue);
            if (cmp != 0)
            {
                return cmp;
            }
            return string.CompareOrdinal(MasterCellAddress, other.MasterCellAddress);
        }

        public bool Equals(FormulaData other)
        {
            if (other is null)
            {
                return false;
            }
            if (ReferenceEquals(this, other))
            {
                return true;
            }
            return string.Equals(Expression, other.Expression, StringComparison.Ordinal)
                && Type == other.Type
                && string.Equals(FormulaRange, other.FormulaRange, StringComparison.Ordinal)
                && EqualityComparer<DefinedName>.Default.Equals(DefinedNameReference, other.DefinedNameReference)
                && EqualityComparer<object>.Default.Equals(CachedValue, other.CachedValue)
                && CachedValueType == other.CachedValueType
                && string.Equals(MasterCellAddress, other.MasterCellAddress, StringComparison.Ordinal);
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as FormulaData);
        }

        public override int GetHashCode()
        {
            unchecked
            {
                int hash = 17;
                hash = (hash * 31) + (Expression != null ? Expression.GetHashCode() : 0);
                hash = (hash * 31) + Type.GetHashCode();
                hash = (hash * 31) + (FormulaRange != null ? FormulaRange.GetHashCode() : 0);
                hash = (hash * 31) + (DefinedNameReference != null ? DefinedNameReference.GetHashCode() : 0);
                hash = (hash * 31) + (CachedValue != null ? CachedValue.GetHashCode() : 0);
                hash = (hash * 31) + CachedValueType.GetHashCode();
                hash = (hash * 31) + (MasterCellAddress != null ? MasterCellAddress.GetHashCode() : 0);
                return hash;
            }
        }
        #endregion
    }
}