EPPlus/Table/ExcelTableCollection.cs

/*******************************************************************************
 * You may amend and distribute as you like, but don't remove this header!
 *
 * EPPlus provides server-side generation of Excel 2007/2010 spreadsheets.
 * See http://www.codeplex.com/EPPlus for details.
 *
 * Copyright (C) 2011  Jan Källman
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Lesser General Public License for more details.
 *
 * The GNU Lesser General Public License can be viewed at http://www.opensource.org/licenses/lgpl-license.php
 * If you unfamiliar with this license or have questions about it, here is an http://www.gnu.org/licenses/gpl-faq.html
 *
 * All code and executables are provided "as is" with no warranty either express or implied.
 * The author accepts no liability for any damage or loss of business that this product may cause.
 *
 * Code change notes:
 *
 * Author							Change						Date
 * ******************************************************************************
 * Jan Källman		Added		30-AUG-2010
 * Jan Källman		License changed GPL-->LGPL 2011-12-16
 *******************************************************************************/

using System;
using System.Collections;
using System.Collections.Generic;
using System.Xml;

namespace OfficeOpenXml.Table;

/// <summary>
/// A collection of table objects
/// </summary>
public class ExcelTableCollection : IEnumerable<ExcelTable> {
  private readonly List<ExcelTable> _tables = new();
  internal Dictionary<string, int> _tableNames = new(StringComparer.InvariantCultureIgnoreCase);
  private readonly ExcelWorksheet _ws;

  internal ExcelTableCollection(ExcelWorksheet ws) {
    var pck = ws._package.Package;
    _ws = ws;
    foreach (XmlElement node in ws.WorksheetXml.SelectNodes(
        "//d:tableParts/d:tablePart",
        ws.NameSpaceManager)) {
      var rel = ws.Part.GetRelationship(node.GetAttribute("id", ExcelPackage._schemaRelationships));
      var tbl = new ExcelTable(rel, ws);
      _tableNames.Add(tbl.Name, _tables.Count);
      _tables.Add(tbl);
    }
  }

  private ExcelTable Add(ExcelTable tbl) {
    _tables.Add(tbl);
    _tableNames.Add(tbl.Name, _tables.Count - 1);
    if (tbl.Id >= _ws.Workbook._nextTableID) {
      _ws.Workbook._nextTableID = tbl.Id + 1;
    }
    return tbl;
  }

  /// <summary>
  /// Create a table on the supplied range
  /// </summary>
  /// <param name="range">The range address including header and total row</param>
  /// <param name="name">The name of the table. Must be unique </param>
  /// <returns>The table object</returns>
  public ExcelTable Add(ExcelAddressBase range, string name) {
    if (range.WorkSheet != null && range.WorkSheet != _ws.Name) {
      throw new ArgumentException("Range does not belong to worksheet", "range");
    }

    if (string.IsNullOrEmpty(name)) {
      name = GetNewTableName();
    } else if (_ws.Workbook.ExistsTableName(name)) {
      throw (new ArgumentException("Tablename is not unique"));
    }

    ValidateTableName(name);

    foreach (var t in _tables) {
      if (t.Address.Collide(range) != ExcelAddressBase.eAddressCollition.No) {
        throw (new ArgumentException(string.Format("Table range collides with table {0}", t.Name)));
      }
    }
    return Add(new(_ws, range, name, _ws.Workbook._nextTableID));
  }

  private void ValidateTableName(string name) {
    if (string.IsNullOrEmpty(name)) {
      throw new ArgumentException("Tablename is null or empty");
    }

    char firstLetterOfName = name[0];
    if (Char.IsLetter(firstLetterOfName) == false
        && firstLetterOfName != '_'
        && firstLetterOfName != '\\') {
      throw new ArgumentException("Tablename start with invalid character");
    }

    if (name.Contains(" ")) {
      throw new ArgumentException("Tablename has spaces");
    }
  }

  public void Delete(int index, bool clearRange = false) {
    Delete(this[index], clearRange);
  }

  public void Delete(string name, bool clearRange = false) {
    if (this[name] == null) {
      throw new ArgumentOutOfRangeException(
          string.Format("Cannot delete non-existant table {0} in sheet {1}.", name, _ws.Name));
    }
    Delete(this[name], clearRange);
  }

  public void Delete(ExcelTable excelTable, bool clearRange = false) {
    if (!_tables.Contains(excelTable)) {
      throw new ArgumentOutOfRangeException(
          "excelTable",
          String.Format("Table {0} does not exist in this collection", excelTable.Name));
    }
    lock (this) {
      var range = _ws.Cells[excelTable.Address.Address];
      _tableNames.Remove(excelTable.Name);
      _tables.Remove(excelTable);
      foreach (var sheet in excelTable.WorkSheet.Workbook.Worksheets) {
        foreach (var table in sheet.Tables) {
          if (table.Id > excelTable.Id) {
            table.Id--;
          }
        }
        excelTable.WorkSheet.Workbook._nextTableID--;
      }
      if (clearRange) {
        range.Clear();
      }
    }
  }

  internal string GetNewTableName() {
    string name = "Table1";
    int i = 2;
    while (_ws.Workbook.ExistsTableName(name)) {
      name = string.Format("Table{0}", i++);
    }
    return name;
  }

  /// <summary>
  /// Number of items in the collection
  /// </summary>
  public int Count => _tables.Count;

  /// <summary>
  /// Get the table object from a range.
  /// </summary>
  /// <param name="range">The range</param>
  /// <returns>The table. Null if no range matches</returns>
  public ExcelTable GetFromRange(ExcelRangeBase range) {
    foreach (var tbl in range.Worksheet.Tables) {
      if (tbl.Address._address == range._address) {
        return tbl;
      }
    }
    return null;
  }

  /// <summary>
  /// The table Index. Base 0.
  /// </summary>
  /// <param name="index"></param>
  /// <returns></returns>
  public ExcelTable this[int index] {
    get {
      if (index < 0 || index >= _tables.Count) {
        throw (new ArgumentOutOfRangeException("Table index out of range"));
      }
      return _tables[index];
    }
  }

  /// <summary>
  /// Indexer
  /// </summary>
  /// <param name="name">The name of the table</param>
  /// <returns>The table. Null if the table name is not found in the collection</returns>
  public ExcelTable this[string name] {
    get {
      if (_tableNames.ContainsKey(name)) {
        return _tables[_tableNames[name]];
      }
      return null;
    }
  }

  public IEnumerator<ExcelTable> GetEnumerator() {
    return _tables.GetEnumerator();
  }

  IEnumerator IEnumerable.GetEnumerator() {
    return _tables.GetEnumerator();
  }
}