AbstractStyle.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;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using NanoXLSX.Exceptions;
 
namespace NanoXLSX.Styles
{
    public abstract class AbstractStyle : IComparable<AbstractStyle>
    {
        [Append(Ignore = true)]
        public int? InternalID { get; set; }
 

        public abstract AbstractStyle Copy();

        internal void CopyProperties<T>(T source, T reference) where T : AbstractStyle
        {
            if (source == null || GetType() != source.GetType() && GetType() != reference.GetType())
            {
                throw new StyleException("The objects of the source, target and reference for style appending are not of the same type");
            }
            PropertyInfo[] infos = GetType().GetProperties();
            PropertyInfo sourceInfo;
            PropertyInfo referenceInfo;
            IEnumerable<AppendAttribute> attributes;
            foreach (PropertyInfo info in infos)
            {
                attributes = info.GetCustomAttributes<AppendAttribute>();
                if (attributes.Any() && !HandleProperties(attributes))
                {
                    continue;
                }
                sourceInfo = source.GetType().GetProperty(info.Name);
                referenceInfo = reference.GetType().GetProperty(info.Name);
                if (!sourceInfo.GetValue(source).Equals(referenceInfo.GetValue(reference)))
                {
                    info.SetValue(this, sourceInfo.GetValue(source));
                }
            }
        }

        private static bool HandleProperties(IEnumerable<AppendAttribute> attributes)
        {
            foreach (AppendAttribute attribute in attributes)
            {
                if (attribute.Ignore || attribute.NestedProperty)
                {
                    return false; // skip property
                }
            }
            return true;
        }

        public int CompareTo(AbstractStyle other)
        {
            if (!InternalID.HasValue)
            {
                return -1;
            }
            else if (other == null || !other.InternalID.HasValue)
            {
                return 1;
            }
            else
            {
                return InternalID.Value.CompareTo(other.InternalID.Value);
            }
        }

        public bool Equals(AbstractStyle other)
        {
            if (other == null)
            {
                return false;
            }
            return this.GetHashCode() == other.GetHashCode();
        }

        internal static void AddPropertyAsJson(StringBuilder sb, string name, object value, bool terminate = false)
        {
            sb.Append('"').Append(name).Append("\": ");
            if (value == null)
            {
                sb.Append("__null__");
            }
            else
            {
                sb.Append('"').Append(value.ToString().Replace("\"", "\\\"")).Append('"');
            }
            if (!terminate)
            {
                sb.Append(",\n");
            }
        }
    }
 
}