| /******************************************************************************* |
| * 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 2012-11-25 |
| *******************************************************************************/ |
| |
| using System; |
| using System.Collections; |
| using System.Collections.Generic; |
| using OfficeOpenXml; |
| |
| internal class IndexBase : IComparable<IndexBase> { |
| internal short Index; |
| |
| public int CompareTo(IndexBase other) { |
| return Index < other.Index |
| ? -1 |
| : Index > other.Index |
| ? 1 |
| : 0; |
| } |
| } |
| |
| internal class IndexItem : IndexBase { |
| internal int IndexPointer { get; set; } |
| } |
| |
| internal class ColumnIndex : IndexBase { |
| internal IndexBase _searchIx = new(); |
| |
| public ColumnIndex() { |
| _pages = new PageIndex[CellStore<int>._pagesPerColumnMin]; |
| PageCount = 0; |
| } |
| |
| ~ColumnIndex() { |
| _pages = null; |
| } |
| |
| internal int GetPosition(int row) { |
| var page = (short)(row >> CellStore<int>._pageBits); |
| _searchIx.Index = page; |
| var res = |
| (_pages != null |
| && page >= 0 |
| && page < PageCount |
| && page < _pages.Length |
| && _pages[page] != null |
| && _pages[page].Index == page) |
| ? page |
| : Array.BinarySearch(_pages, 0, PageCount, _searchIx); |
| if (res >= 0) { |
| GetPage(row, ref res); |
| return res; |
| } |
| var p = ~res; |
| |
| if (GetPage(row, ref p)) { |
| return p; |
| } |
| return res; |
| } |
| |
| private bool GetPage(int row, ref int res) { |
| if (res < PageCount && _pages[res].MinIndex <= row && _pages[res].MaxIndex >= row) { |
| return true; |
| } |
| if (res + 1 < PageCount && (_pages[res + 1].MinIndex <= row)) { |
| do { |
| res++; |
| } while (res + 1 < PageCount && _pages[res + 1].MinIndex <= row); |
| //if (res + 1 < PageCount && _pages[res + 1].MaxIndex >= Row) |
| //{ |
| return true; |
| //} |
| //else |
| //{ |
| // return false; |
| //} |
| } |
| if (res - 1 >= 0 && _pages[res - 1].MaxIndex >= row) { |
| do { |
| res--; |
| } while (res - 1 > 0 && _pages[res - 1].MaxIndex >= row); |
| //if (res > 0) |
| //{ |
| return true; |
| //} |
| //else |
| //{ |
| // return false; |
| //} |
| } |
| return false; |
| } |
| |
| internal int GetNextRow(int row) { |
| //var page = (int)((ulong)row >> CellStore<int>.pageBits); |
| var p = GetPosition(row); |
| if (p < 0) { |
| p = ~p; |
| if (p >= PageCount) { |
| return -1; |
| } |
| if (_pages[p].IndexOffset + _pages[p].Rows[0].Index < row) { |
| if (p + 1 >= PageCount) { |
| return -1; |
| } |
| return _pages[p + 1].IndexOffset + _pages[p].Rows[0].Index; |
| } |
| return _pages[p].IndexOffset + _pages[p].Rows[0].Index; |
| } |
| if (p < PageCount) { |
| var r = _pages[p].GetNextRow(row); |
| if (r >= 0) { |
| return _pages[p].IndexOffset + _pages[p].Rows[r].Index; |
| } else { |
| if (++p < PageCount) { |
| return _pages[p].IndexOffset + _pages[p].Rows[0].Index; |
| } else { |
| return -1; |
| } |
| } |
| } |
| return -1; |
| } |
| |
| internal int FindNext(int page) { |
| var p = GetPosition(page); |
| if (p < 0) { |
| return ~p; |
| } |
| return p; |
| } |
| |
| internal PageIndex[] _pages; |
| internal int PageCount; |
| } |
| |
| internal class PageIndex : IndexBase { |
| internal IndexBase _searchIx = new(); |
| |
| public PageIndex() { |
| Rows = new IndexItem[CellStore<int>._pageSizeMin]; |
| RowCount = 0; |
| } |
| |
| public PageIndex(IndexItem[] rows, int count) { |
| Rows = rows; |
| RowCount = count; |
| } |
| |
| public PageIndex(PageIndex pageItem, int start, int size) |
| : this(pageItem, start, size, pageItem.Index, pageItem.Offset) {} |
| |
| public PageIndex(PageIndex pageItem, int start, int size, short index, int offset) { |
| Rows = new IndexItem[CellStore<int>.GetSize(size)]; |
| Array.Copy(pageItem.Rows, start, Rows, 0, size); |
| RowCount = size; |
| Index = index; |
| Offset = offset; |
| } |
| |
| ~PageIndex() { |
| Rows = null; |
| } |
| |
| internal int Offset; |
| |
| internal int IndexOffset => IndexExpanded + Offset; |
| |
| internal int IndexExpanded => (Index << CellStore<int>._pageBits); |
| |
| internal IndexItem[] Rows { get; set; } |
| |
| internal int RowCount; |
| |
| internal int GetPosition(int offset) { |
| _searchIx.Index = (short)offset; |
| return (Rows != null |
| && offset > 0 |
| && offset - 1 < RowCount |
| && offset - 1 < Rows.Length |
| && Rows[offset - 1] != null |
| && Rows[offset - 1].Index == offset) |
| ? offset - 1 |
| : Array.BinarySearch(Rows, 0, RowCount, _searchIx); |
| } |
| |
| internal int GetNextRow(int row) { |
| int offset = row - IndexOffset; |
| var o = GetPosition(offset); |
| if (o < 0) { |
| o = ~o; |
| if (o < RowCount) { |
| return o; |
| } |
| return -1; |
| } |
| return o; |
| } |
| |
| public int MinIndex { |
| get { |
| if (Rows.Length > 0) { |
| return IndexOffset + Rows[0].Index; |
| } |
| return -1; |
| } |
| } |
| |
| public int MaxIndex { |
| get { |
| if (RowCount > 0) { |
| return IndexOffset + Rows[RowCount - 1].Index; |
| } |
| return -1; |
| } |
| } |
| |
| public int GetIndex(int pos) { |
| return IndexOffset + Rows[pos].Index; |
| } |
| } |
| |
| /// <summary> |
| /// This is the store for all Rows, Columns and Cells. |
| /// It is a Dictionary implementation that allows you to change the Key (the RowID, ColumnID or CellID ) |
| /// </summary> |
| internal class CellStore<T> { |
| /**** Size constants ****/ |
| internal const int _pageBits = 10; //13bits=8192 Note: Maximum is 13 bits since short is used (PageMax=16K) |
| internal const int _pageSize = 1 << _pageBits; |
| internal const int _pageSizeMin = 1 << 10; |
| internal const int _pageSizeMax = _pageSize << 1; //Double page size |
| internal const int _colSizeMin = 32; |
| internal const int _pagesPerColumnMin = 32; |
| |
| private List<T> _values = new(); |
| internal ColumnIndex[] _columnIndex; |
| internal IndexBase _searchIx = new(); |
| internal int ColumnCount; |
| |
| public CellStore() { |
| _columnIndex = new ColumnIndex[_colSizeMin]; |
| } |
| |
| ~CellStore() { |
| if (_values != null) { |
| _values.Clear(); |
| _values = null; |
| } |
| _columnIndex = null; |
| } |
| |
| internal int GetPosition(int column) { |
| _searchIx.Index = (short)column; |
| return (_columnIndex != null |
| && column > 0 |
| && column - 1 < ColumnCount |
| && column - 1 < _columnIndex.Length |
| && _columnIndex[column - 1] != null |
| && _columnIndex[column - 1].Index == column) |
| ? column - 1 |
| : Array.BinarySearch(_columnIndex, 0, ColumnCount, _searchIx); |
| } |
| |
| internal CellStore<T> Clone() { |
| int row, |
| col; |
| var ret = new CellStore<T>(); |
| for (int c = 0; c < ColumnCount; c++) { |
| col = _columnIndex[c].Index; |
| for (int p = 0; p < _columnIndex[c].PageCount; p++) { |
| for (int r = 0; r < _columnIndex[c]._pages[p].RowCount; r++) { |
| row = _columnIndex[c]._pages[p].IndexOffset + _columnIndex[c]._pages[p].Rows[r].Index; |
| ret.SetValue(row, col, _values[_columnIndex[c]._pages[p].Rows[r].IndexPointer]); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| internal int Count { |
| get { |
| int count = 0; |
| for (int c = 0; c < ColumnCount; c++) { |
| for (int p = 0; p < _columnIndex[c].PageCount; p++) { |
| count += _columnIndex[c]._pages[p].RowCount; |
| } |
| } |
| return count; |
| } |
| } |
| |
| internal bool GetDimension(out int fromRow, out int fromCol, out int toRow, out int toCol) { |
| if (ColumnCount == 0) { |
| fromRow = fromCol = toRow = toCol = 0; |
| return false; |
| } |
| fromCol = _columnIndex[0].Index; |
| var fromIndex = 0; |
| if (fromCol <= 0 && ColumnCount > 1) { |
| fromCol = _columnIndex[1].Index; |
| fromIndex = 1; |
| } else if (ColumnCount == 1 && fromCol <= 0) { |
| fromRow = fromCol = toRow = toCol = 0; |
| return false; |
| } |
| var col = ColumnCount - 1; |
| while (col > 0) { |
| if (_columnIndex[col].PageCount == 0 |
| || _columnIndex[col]._pages[0].RowCount > 1 |
| || _columnIndex[col]._pages[0].Rows[0].Index > 0) { |
| break; |
| } |
| col--; |
| } |
| toCol = _columnIndex[col].Index; |
| if (toCol == 0) { |
| fromRow = fromCol = toRow = toCol = 0; |
| return false; |
| } |
| fromRow = toRow = 0; |
| |
| for (int c = fromIndex; c < ColumnCount; c++) { |
| int first, |
| last; |
| if (_columnIndex[c].PageCount == 0) { |
| continue; |
| } |
| if (_columnIndex[c]._pages[0].RowCount > 0 && _columnIndex[c]._pages[0].Rows[0].Index > 0) { |
| first = _columnIndex[c]._pages[0].IndexOffset + _columnIndex[c]._pages[0].Rows[0].Index; |
| } else { |
| if (_columnIndex[c]._pages[0].RowCount > 1) { |
| first = _columnIndex[c]._pages[0].IndexOffset + _columnIndex[c]._pages[0].Rows[1].Index; |
| } else if (_columnIndex[c].PageCount > 1) { |
| first = _columnIndex[c]._pages[0].IndexOffset + _columnIndex[c]._pages[1].Rows[0].Index; |
| } else { |
| first = 0; |
| } |
| } |
| var lp = _columnIndex[c].PageCount - 1; |
| while (_columnIndex[c]._pages[lp].RowCount == 0 && lp != 0) { |
| lp--; |
| } |
| var p = _columnIndex[c]._pages[lp]; |
| if (p.RowCount > 0) { |
| last = p.IndexOffset + p.Rows[p.RowCount - 1].Index; |
| } else { |
| last = first; |
| } |
| if (first > 0 && (first < fromRow || fromRow == 0)) { |
| fromRow = first; |
| } |
| if (first > 0 && (last > toRow || toRow == 0)) { |
| toRow = last; |
| } |
| } |
| if (fromRow <= 0 || toRow <= 0) { |
| fromRow = fromCol = toRow = toCol = 0; |
| return false; |
| } |
| return true; |
| } |
| |
| internal int FindNext(int column) { |
| var c = GetPosition(column); |
| if (c < 0) { |
| return ~c; |
| } |
| return c; |
| } |
| |
| internal T GetValue(int row, int column) { |
| int i = GetPointer(row, column); |
| if (i >= 0) { |
| return _values[i]; |
| } |
| return default(T); |
| //var col = GetPosition(Column); |
| //if (col >= 0) |
| //{ |
| // var pos = _columnIndex[col].GetPosition(Row); |
| // if (pos >= 0) |
| // { |
| // var pageItem = _columnIndex[col].Pages[pos]; |
| // if (pageItem.MinIndex > Row) |
| // { |
| // pos--; |
| // if (pos < 0) |
| // { |
| // return default(T); |
| // } |
| // else |
| // { |
| // pageItem = _columnIndex[col].Pages[pos]; |
| // } |
| // } |
| // short ix = (short)(Row - pageItem.IndexOffset); |
| // var cellPos = Array.BinarySearch(pageItem.Rows, 0, pageItem.RowCount, new IndexBase() { Index = ix }); |
| // if (cellPos >= 0) |
| // { |
| // return _values[pageItem.Rows[cellPos].IndexPointer]; |
| // } |
| // else //Cell does not exist |
| // { |
| // return default(T); |
| // } |
| // } |
| // else //Page does not exist |
| // { |
| // return default(T); |
| // } |
| //} |
| //else //Column does not exist |
| //{ |
| // return default(T); |
| //} |
| } |
| |
| private int GetPointer(int row, int column) { |
| var col = GetPosition(column); |
| if (col >= 0) { |
| var pos = _columnIndex[col].GetPosition(row); |
| if (pos >= 0 && pos < _columnIndex[col].PageCount) { |
| var pageItem = _columnIndex[col]._pages[pos]; |
| if (pageItem.MinIndex > row) { |
| pos--; |
| if (pos < 0) { |
| return -1; |
| } |
| pageItem = _columnIndex[col]._pages[pos]; |
| } |
| short ix = (short)(row - pageItem.IndexOffset); |
| _searchIx.Index = ix; |
| var cellPos = |
| (pageItem.Rows != null |
| && ix > 0 |
| && ix - 1 < pageItem.RowCount |
| && ix - 1 < pageItem.Rows.Length |
| && pageItem.Rows[ix - 1] != null |
| && pageItem.Rows[ix - 1].Index == ix) |
| ? ix - 1 |
| : Array.BinarySearch(pageItem.Rows, 0, pageItem.RowCount, _searchIx); |
| if (cellPos >= 0) { |
| return pageItem.Rows[cellPos].IndexPointer; |
| } //Cell does not exist |
| return -1; |
| } //Page does not exist |
| return -1; |
| } //Column does not exist |
| return -1; |
| } |
| |
| internal bool Exists(int row, int column) { |
| return GetPointer(row, column) >= 0; |
| } |
| |
| internal bool Exists(int row, int column, ref T value) { |
| var p = GetPointer(row, column); |
| if (p >= 0) { |
| value = _values[p]; |
| return true; |
| } |
| return false; |
| } |
| |
| internal void SetValue(int row, int column, T value) { |
| lock (_columnIndex) { |
| var col = |
| (_columnIndex != null |
| && column > 0 |
| && column - 1 < ColumnCount |
| && column - 1 < _columnIndex.Length |
| && _columnIndex[column - 1] != null |
| && _columnIndex[column - 1].Index == column) |
| ? column - 1 |
| : Array.BinarySearch( |
| _columnIndex, |
| 0, |
| ColumnCount, |
| new IndexBase { |
| Index = (short)(column), |
| }); |
| var page = (short)(row >> _pageBits); |
| if (col >= 0) { |
| //var pos = Array.BinarySearch(_columnIndex[col].Pages, 0, _columnIndex[col].Count, new IndexBase() { Index = page }); |
| var pos = _columnIndex[col].GetPosition(row); |
| if (pos < 0) { |
| pos = ~pos; |
| if (pos - 1 < 0 || _columnIndex[col]._pages[pos - 1].IndexOffset + _pageSize - 1 < row) { |
| AddPage(_columnIndex[col], pos, page); |
| } else { |
| pos--; |
| } |
| } |
| if (pos >= _columnIndex[col].PageCount) { |
| AddPage(_columnIndex[col], pos, page); |
| } |
| var pageItem = _columnIndex[col]._pages[pos]; |
| if (pageItem.IndexOffset > row) { |
| pos--; |
| page--; |
| if (pos < 0) { |
| throw (new("Unexpected error when setting value")); |
| } |
| pageItem = _columnIndex[col]._pages[pos]; |
| } |
| |
| short ix = (short)(row - ((pageItem.Index << _pageBits) + pageItem.Offset)); |
| _searchIx.Index = ix; |
| var cellPos = |
| (pageItem.Rows != null |
| && ix >= 0 |
| && ix < pageItem.RowCount |
| && ix < pageItem.Rows.Length |
| && pageItem.Rows[ix] != null |
| && pageItem.Rows[ix].Index == ix) |
| ? ix |
| : Array.BinarySearch(pageItem.Rows, 0, pageItem.RowCount, _searchIx); |
| if (cellPos < 0) { |
| cellPos = ~cellPos; |
| AddCell(_columnIndex[col], pos, cellPos, ix, value); |
| } else { |
| _values[pageItem.Rows[cellPos].IndexPointer] = value; |
| } |
| } else //Column does not exist |
| { |
| col = ~col; |
| AddColumn(col, column); |
| AddPage(_columnIndex[col], 0, page); |
| short ix = (short)(row - (page << _pageBits)); |
| AddCell(_columnIndex[col], 0, 0, ix, value); |
| } |
| } |
| } |
| |
| internal void Insert(int fromRow, int fromCol, int rows, int columns) { |
| lock (_columnIndex) { |
| if (columns > 0) { |
| var col = GetPosition(fromCol); |
| if (col < 0) { |
| col = ~col; |
| } |
| for (var c = col; c < ColumnCount; c++) { |
| _columnIndex[c].Index += (short)columns; |
| } |
| } else { |
| var page = fromRow >> _pageBits; |
| for (int c = 0; c < ColumnCount; c++) { |
| var column = _columnIndex[c]; |
| var pagePos = column.GetPosition(fromRow); |
| if (pagePos >= 0) { |
| if (fromRow >= column._pages[pagePos].MinIndex |
| && fromRow |
| <= column._pages[pagePos].MaxIndex) //The row is inside the page |
| { |
| int offset = fromRow - column._pages[pagePos].IndexOffset; |
| var rowPos = column._pages[pagePos].GetPosition(offset); |
| if (rowPos < 0) { |
| rowPos = ~rowPos; |
| } |
| UpdateIndexOffset(column, pagePos, rowPos, fromRow, rows); |
| } else if (column._pages[pagePos].MinIndex > fromRow - 1 |
| && pagePos |
| > 0) //The row is on the page before. |
| { |
| int offset = fromRow - ((page - 1) << _pageBits); |
| var rowPos = column._pages[pagePos - 1].GetPosition(offset); |
| if (rowPos > 0 && pagePos > 0) { |
| UpdateIndexOffset(column, pagePos - 1, rowPos, fromRow, rows); |
| } |
| } else if (column.PageCount >= pagePos + 1) { |
| int offset = fromRow - column._pages[pagePos].IndexOffset; |
| var rowPos = column._pages[pagePos].GetPosition(offset); |
| if (rowPos < 0) { |
| rowPos = ~rowPos; |
| } |
| if (column._pages[pagePos].RowCount > rowPos) { |
| UpdateIndexOffset(column, pagePos, rowPos, fromRow, rows); |
| } else { |
| UpdateIndexOffset(column, pagePos + 1, 0, fromRow, rows); |
| } |
| } |
| } else { |
| UpdateIndexOffset(column, ~pagePos, 0, fromRow, rows); |
| } |
| } |
| } |
| } |
| } |
| |
| internal void Clear(int fromRow, int fromCol, int rows, int columns) { |
| Delete(fromRow, fromCol, rows, columns, false); |
| } |
| |
| internal void Delete(int fromRow, int fromCol, int rows, int columns) { |
| Delete(fromRow, fromCol, rows, columns, true); |
| } |
| |
| internal void Delete(int fromRow, int fromCol, int rows, int columns, bool shift) { |
| lock (_columnIndex) { |
| if (columns > 0 && fromRow == 1 && rows >= ExcelPackage.MaxRows) { |
| DeleteColumns(fromCol, columns, shift); |
| } else { |
| var toCol = fromCol + columns - 1; |
| var pageFromRow = fromRow >> _pageBits; |
| for (int c = 0; c < ColumnCount; c++) { |
| var column = _columnIndex[c]; |
| if (column.Index >= fromCol) { |
| if (column.Index > toCol) { |
| break; |
| } |
| var pagePos = column.GetPosition(fromRow); |
| if (pagePos < 0) { |
| pagePos = ~pagePos; |
| } |
| if (pagePos < column.PageCount) { |
| var page = column._pages[pagePos]; |
| if (shift |
| && page.RowCount > 0 |
| && page.MinIndex > fromRow |
| && page.MaxIndex >= fromRow + rows) { |
| var o = page.MinIndex - fromRow; |
| if (o < rows) { |
| rows -= o; |
| page.Offset -= o; |
| UpdatePageOffset(column, pagePos, o); |
| } else { |
| page.Offset -= rows; |
| UpdatePageOffset(column, pagePos, rows); |
| continue; |
| } |
| } |
| if (page.RowCount > 0 |
| && page.MinIndex <= fromRow + rows - 1 |
| && page.MaxIndex |
| >= fromRow) //The row is inside the page |
| { |
| var endRow = fromRow + rows; |
| var delEndRow = DeleteCells(column._pages[pagePos], fromRow, endRow, shift); |
| if (shift && delEndRow != fromRow) { |
| UpdatePageOffset(column, pagePos, delEndRow - fromRow); |
| } |
| if (endRow > delEndRow |
| && pagePos < column.PageCount |
| && column._pages[pagePos].MinIndex < endRow) { |
| pagePos = (delEndRow == fromRow ? pagePos : pagePos + 1); |
| var rowsLeft = DeletePage( |
| shift ? fromRow : delEndRow, |
| endRow - delEndRow, |
| column, |
| pagePos, |
| shift); |
| //if (shift) UpdatePageOffset(column, pagePos, endRow - fromRow - rowsLeft); |
| if (rowsLeft > 0) { |
| var fr = shift ? fromRow : endRow - rowsLeft; |
| pagePos = column.GetPosition(fr); |
| delEndRow = DeleteCells( |
| column._pages[pagePos], |
| fr, |
| shift ? fr + rowsLeft : endRow, |
| shift); |
| if (shift) { |
| UpdatePageOffset(column, pagePos, rowsLeft); |
| } |
| } |
| } |
| } else if (pagePos > 0 |
| && column._pages[pagePos].IndexOffset |
| > fromRow) //The row is on the page before. |
| { |
| int offset = fromRow + rows - 1 - ((pageFromRow - 1) << _pageBits); |
| var rowPos = column._pages[pagePos - 1].GetPosition(offset); |
| if (rowPos > 0 && pagePos > 0) { |
| if (shift) { |
| UpdateIndexOffset(column, pagePos - 1, rowPos, fromRow + rows - 1, -rows); |
| } |
| } |
| } else { |
| if (shift && pagePos + 1 < column.PageCount) { |
| UpdateIndexOffset( |
| column, |
| pagePos + 1, |
| 0, |
| column._pages[pagePos + 1].MinIndex, |
| -rows); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| private void UpdatePageOffset(ColumnIndex column, int pagePos, int rows) { |
| //Update Pageoffset |
| |
| if (++pagePos < column.PageCount) { |
| for (int p = pagePos; p < column.PageCount; p++) { |
| if (column._pages[p].Offset - rows <= -_pageSize) { |
| column._pages[p].Index--; |
| column._pages[p].Offset -= rows - _pageSize; |
| } else { |
| column._pages[p].Offset -= rows; |
| } |
| } |
| |
| if (Math.Abs(column._pages[pagePos].Offset) > _pageSize |
| || Math.Abs(column._pages[pagePos].Rows[column._pages[pagePos].RowCount - 1].Index) |
| > _pageSizeMax) //Split or Merge??? |
| { |
| rows = ResetPageOffset(column, pagePos, rows); |
| ////MergePages |
| //if (column.Pages[pagePos - 1].Index + 1 == column.Pages[pagePos].Index) |
| //{ |
| // if (column.Pages[pagePos].IndexOffset + column.Pages[pagePos].Rows[column.Pages[pagePos].RowCount - 1].Index + rows - |
| // column.Pages[pagePos - 1].IndexOffset + column.Pages[pagePos - 1].Rows[0].Index <= PageSize) |
| // { |
| // //Merge |
| // MergePage(column, pagePos - 1, -rows); |
| // } |
| // else |
| // { |
| // //Split |
| // } |
| //} |
| //rows -= PageSize; |
| //for (int p = pagePos; p < column.PageCount; p++) |
| //{ |
| // column.Pages[p].Index -= 1; |
| //} |
| } |
| } |
| } |
| |
| private int ResetPageOffset(ColumnIndex column, int pagePos, int rows) { |
| PageIndex fromPage = column._pages[pagePos]; |
| PageIndex toPage; |
| short pageAdd = 0; |
| if (fromPage.Offset < -_pageSize) { |
| toPage = column._pages[pagePos - 1]; |
| pageAdd = -1; |
| if (fromPage.Index - 1 == toPage.Index) { |
| if (fromPage.IndexOffset |
| + fromPage.Rows[fromPage.RowCount - 1].Index |
| - toPage.IndexOffset |
| + toPage.Rows[0].Index |
| <= _pageSizeMax) { |
| MergePage(column, pagePos - 1); |
| //var newPage = new PageIndex(toPage, 0, GetSize(fromPage.RowCount + toPage.RowCount)); |
| //newPage.RowCount = fromPage.RowCount + fromPage.RowCount; |
| //Array.Copy(toPage.Rows, 0, newPage.Rows, 0, toPage.RowCount); |
| //Array.Copy(fromPage.Rows, 0, newPage.Rows, toPage.RowCount, fromPage.RowCount); |
| //for (int r = toPage.RowCount; r < newPage.RowCount; r++) |
| //{ |
| // newPage.Rows[r].Index += (short)(fromPage.IndexOffset - toPage.IndexOffset); |
| //} |
| } |
| } else //No page after |
| { |
| fromPage.Index -= pageAdd; |
| fromPage.Offset += _pageSize; |
| } |
| } else if (fromPage.Offset > _pageSize) { |
| toPage = column._pages[pagePos + 1]; |
| pageAdd = 1; |
| if (fromPage.Index + 1 == toPage.Index) {} else { |
| fromPage.Index += pageAdd; |
| fromPage.Offset += _pageSize; |
| } |
| } |
| return rows; |
| } |
| |
| private int DeletePage(int fromRow, int rows, ColumnIndex column, int pagePos, bool shift) { |
| PageIndex page = column._pages[pagePos]; |
| var startRows = rows; |
| while (page != null |
| && page.MinIndex >= fromRow |
| && ((shift && page.MaxIndex < fromRow + rows) |
| || (!shift && page.MaxIndex < fromRow + startRows))) { |
| //Delete entire page. |
| var delSize = page.MaxIndex - page.MinIndex + 1; |
| rows -= delSize; |
| var prevOffset = page.Offset; |
| Array.Copy( |
| column._pages, |
| pagePos + 1, |
| column._pages, |
| pagePos, |
| column.PageCount - pagePos + 1); |
| column.PageCount--; |
| if (column.PageCount == 0) { |
| return 0; |
| } |
| if (shift) { |
| for (int i = pagePos; i < column.PageCount; i++) { |
| column._pages[i].Offset -= delSize; |
| if (column._pages[i].Offset <= -_pageSize) { |
| column._pages[i].Index--; |
| column._pages[i].Offset += _pageSize; |
| } |
| } |
| } |
| if (column.PageCount > pagePos) { |
| page = column._pages[pagePos]; |
| //page.Offset = pagePos == 0 ? 1 : prevOffset; //First page can only reference to rows starting from Index == 1 |
| } else { |
| //No more pages, return 0 |
| return 0; |
| } |
| } |
| return rows; |
| } |
| |
| /// |
| private int DeleteCells(PageIndex page, int fromRow, int toRow, bool shift) { |
| var fromPos = page.GetPosition(fromRow - (page.IndexOffset)); |
| if (fromPos < 0) { |
| fromPos = ~fromPos; |
| } |
| var maxRow = page.MaxIndex; |
| var offset = toRow - page.IndexOffset; |
| if (offset > _pageSizeMax) { |
| offset = _pageSizeMax; |
| } |
| var toPos = page.GetPosition(offset); |
| if (toPos < 0) { |
| toPos = ~toPos; |
| } |
| |
| if (fromPos <= toPos && fromPos < page.RowCount && page.GetIndex(fromPos) < toRow) { |
| if (toRow > page.MaxIndex) { |
| if (fromRow |
| == page.MinIndex) //Delete entire page, late in the page delete method |
| { |
| return fromRow; |
| } |
| var r = page.MaxIndex; |
| var deletedRow = page.RowCount - fromPos; |
| page.RowCount -= deletedRow; |
| return r + 1; |
| } |
| var rows = toRow - fromRow; |
| if (shift) { |
| UpdateRowIndex(page, toPos, rows); |
| } |
| Array.Copy(page.Rows, toPos, page.Rows, fromPos, page.RowCount - toPos); |
| page.RowCount -= toPos - fromPos; |
| |
| return toRow; |
| } |
| if (shift) { |
| UpdateRowIndex(page, toPos, toRow - fromRow); |
| } |
| return toRow < maxRow ? toRow : maxRow; |
| } |
| |
| private static void UpdateRowIndex(PageIndex page, int toPos, int rows) { |
| for (int r = toPos; r < page.RowCount; r++) { |
| page.Rows[r].Index -= (short)rows; |
| } |
| } |
| |
| private void DeleteColumns(int fromCol, int columns, bool shift) { |
| var fPos = GetPosition(fromCol); |
| if (fPos < 0) { |
| fPos = ~fPos; |
| } |
| int tPos = fPos; |
| for (var c = fPos; c <= ColumnCount; c++) { |
| tPos = c; |
| if (tPos == ColumnCount || _columnIndex[c].Index >= fromCol + columns) { |
| break; |
| } |
| } |
| |
| if (ColumnCount <= fPos) { |
| return; |
| } |
| |
| if (_columnIndex[fPos].Index >= fromCol && _columnIndex[fPos].Index <= fromCol + columns) { |
| //if (_columnIndex[fPos].Index < ColumnCount) |
| //{ |
| if (tPos < ColumnCount) { |
| Array.Copy(_columnIndex, tPos, _columnIndex, fPos, ColumnCount - tPos); |
| } |
| ColumnCount -= (tPos - fPos); |
| //} |
| } |
| if (shift) { |
| for (var c = fPos; c < ColumnCount; c++) { |
| _columnIndex[c].Index -= (short)columns; |
| } |
| } |
| } |
| |
| private void UpdateIndexOffset(ColumnIndex column, int pagePos, int rowPos, int row, int rows) { |
| if (pagePos >= column.PageCount) { |
| return; //A page after last cell. |
| } |
| var page = column._pages[pagePos]; |
| if (rows > _pageSize) { |
| short addPages = (short)(rows >> _pageBits); |
| int offset = +(rows - (_pageSize * addPages)); |
| for (int p = pagePos + 1; p < column.PageCount; p++) { |
| if (column._pages[p].Offset + offset > _pageSize) { |
| column._pages[p].Index += (short)(addPages + 1); |
| column._pages[p].Offset += offset - _pageSize; |
| } else { |
| column._pages[p].Index += addPages; |
| column._pages[p].Offset += offset; |
| } |
| } |
| |
| var size = page.RowCount - rowPos; |
| if (page.RowCount > rowPos) { |
| if (column.PageCount - 1 |
| == pagePos) //No page after, create a new one. |
| { |
| //Copy rows to next page. |
| var newPage = CopyNew(page, rowPos, size); |
| newPage.Index = (short)((row + rows) >> _pageBits); |
| newPage.Offset = row + rows - (newPage.Index * _pageSize) - newPage.Rows[0].Index; |
| if (newPage.Offset > _pageSize) { |
| newPage.Index++; |
| newPage.Offset -= _pageSize; |
| } |
| AddPage(column, pagePos + 1, newPage); |
| page.RowCount = rowPos; |
| } else { |
| if (column._pages[pagePos + 1].RowCount + size |
| > _pageSizeMax) //Split Page |
| { |
| SplitPageInsert(column, pagePos, rowPos, rows, size, addPages); |
| } else //Copy Page. |
| { |
| CopyMergePage(page, rowPos, rows, size, column._pages[pagePos + 1]); |
| } |
| } |
| } |
| } else { |
| //Add to Pages. |
| for (int r = rowPos; r < page.RowCount; r++) { |
| page.Rows[r].Index += (short)rows; |
| } |
| if (page.Offset + page.Rows[page.RowCount - 1].Index |
| >= _pageSizeMax) //Can not be larger than the max size of the page. |
| { |
| AdjustIndex(column, pagePos); |
| if (page.Offset + page.Rows[page.RowCount - 1].Index >= _pageSizeMax) { |
| pagePos = SplitPage(column, pagePos); |
| } |
| //IndexItem[] newRows = new IndexItem[GetSize(page.RowCount - page.Rows[r].Index)]; |
| //var newPage = new PageIndex(newRows, r); |
| //newPage.Index = (short)(pagePos + 1); |
| //TODO: MoveRows to next page. |
| } |
| |
| for (int p = pagePos + 1; p < column.PageCount; p++) { |
| if (column._pages[p].Offset + rows < _pageSize) { |
| column._pages[p].Offset += rows; |
| } else { |
| column._pages[p].Index++; |
| column._pages[p].Offset = (column._pages[p].Offset + rows) % _pageSize; |
| } |
| } |
| } |
| } |
| |
| private void SplitPageInsert( |
| ColumnIndex column, |
| int pagePos, |
| int rowPos, |
| int rows, |
| int size, |
| int addPages) { |
| var newRows = new IndexItem[GetSize(size)]; |
| var page = column._pages[pagePos]; |
| |
| var rStart = -1; |
| for (int r = rowPos; r < page.RowCount; r++) { |
| if (page.IndexExpanded - (page.Rows[r].Index + rows) > _pageSize) { |
| rStart = r; |
| break; |
| } |
| page.Rows[r].Index += (short)rows; |
| } |
| var rc = page.RowCount - rStart; |
| page.RowCount = rStart; |
| if (rc > 0) { |
| //Copy to a new page |
| var row = page.IndexOffset; |
| var newPage = CopyNew(page, rStart, rc); |
| var ix = (short)(page.Index + addPages); |
| var offset = page.IndexOffset + rows - (ix * _pageSize); |
| if (offset > _pageSize) { |
| ix += (short)(offset / _pageSize); |
| offset %= _pageSize; |
| } |
| newPage.Index = ix; |
| newPage.Offset = offset; |
| AddPage(column, pagePos + 1, newPage); |
| } |
| |
| //Copy from next Row |
| } |
| |
| private void CopyMergePage(PageIndex page, int rowPos, int rows, int size, PageIndex toPage) { |
| var startRow = page.IndexOffset + page.Rows[rowPos].Index + rows; |
| var newRows = new IndexItem[GetSize(toPage.RowCount + size)]; |
| page.RowCount -= size; |
| Array.Copy(page.Rows, rowPos, newRows, 0, size); |
| for (int r = 0; r < size; r++) { |
| newRows[r].Index += (short)(page.IndexOffset + rows - toPage.IndexOffset); |
| } |
| |
| Array.Copy(toPage.Rows, 0, newRows, size, toPage.RowCount); |
| toPage.Rows = newRows; |
| toPage.RowCount += size; |
| } |
| |
| private void MergePage(ColumnIndex column, int pagePos) { |
| PageIndex page1 = column._pages[pagePos]; |
| PageIndex page2 = column._pages[pagePos + 1]; |
| |
| var newPage = new PageIndex(page1, 0, page1.RowCount + page2.RowCount); |
| newPage.RowCount = page1.RowCount + page2.RowCount; |
| Array.Copy(page1.Rows, 0, newPage.Rows, 0, page1.RowCount); |
| Array.Copy(page2.Rows, 0, newPage.Rows, page1.RowCount, page2.RowCount); |
| for (int r = page1.RowCount; r < newPage.RowCount; r++) { |
| newPage.Rows[r].Index += (short)(page2.IndexOffset - page1.IndexOffset); |
| } |
| |
| column._pages[pagePos] = newPage; |
| column.PageCount--; |
| |
| if (column.PageCount > (pagePos + 1)) { |
| Array.Copy( |
| column._pages, |
| pagePos + 2, |
| column._pages, |
| pagePos + 1, |
| column.PageCount - (pagePos + 1)); |
| for (int p = pagePos + 1; p < column.PageCount; p++) { |
| column._pages[p].Index--; |
| column._pages[p].Offset += _pageSize; |
| } |
| } |
| } |
| |
| private PageIndex CopyNew(PageIndex pageFrom, int rowPos, int size) { |
| IndexItem[] newRows = new IndexItem[GetSize(size)]; |
| Array.Copy(pageFrom.Rows, rowPos, newRows, 0, size); |
| return new(newRows, size); |
| } |
| |
| internal static int GetSize(int size) { |
| var newSize = 256; |
| while (newSize < size) { |
| newSize <<= 1; |
| } |
| return newSize; |
| } |
| |
| private void AddCell(ColumnIndex columnIndex, int pagePos, int pos, short ix, T value) { |
| PageIndex pageItem = columnIndex._pages[pagePos]; |
| if (pageItem.RowCount == pageItem.Rows.Length) { |
| if (pageItem.RowCount |
| == _pageSizeMax) //Max size-->Split |
| { |
| pagePos = SplitPage(columnIndex, pagePos); |
| if (columnIndex._pages[pagePos - 1].RowCount > pos) { |
| pagePos--; |
| } else { |
| pos -= columnIndex._pages[pagePos - 1].RowCount; |
| } |
| pageItem = columnIndex._pages[pagePos]; |
| } else //Expand to double size. |
| { |
| var rowsTmp = new IndexItem[pageItem.Rows.Length << 1]; |
| Array.Copy(pageItem.Rows, 0, rowsTmp, 0, pageItem.RowCount); |
| pageItem.Rows = rowsTmp; |
| } |
| } |
| if (pos < pageItem.RowCount) { |
| Array.Copy(pageItem.Rows, pos, pageItem.Rows, pos + 1, pageItem.RowCount - pos); |
| } |
| pageItem.Rows[pos] = new() { |
| Index = ix, |
| IndexPointer = _values.Count, |
| }; |
| _values.Add(value); |
| pageItem.RowCount++; |
| } |
| |
| private int SplitPage(ColumnIndex columnIndex, int pagePos) { |
| var page = columnIndex._pages[pagePos]; |
| if (page.Offset != 0) { |
| var offset = page.Offset; |
| page.Offset = 0; |
| for (int r = 0; r < page.RowCount; r++) { |
| page.Rows[r].Index -= (short)offset; |
| } |
| } |
| //Find Split pos |
| int splitPos = 0; |
| for (int r = 0; r < page.RowCount; r++) { |
| if (page.Rows[r].Index > _pageSize) { |
| splitPos = r; |
| break; |
| } |
| } |
| var newPage = new PageIndex(page, 0, splitPos); |
| var nextPage = new PageIndex( |
| page, |
| splitPos, |
| page.RowCount - splitPos, |
| (short)(page.Index + 1), |
| page.Offset); |
| |
| for (int r = 0; r < nextPage.RowCount; r++) { |
| nextPage.Rows[r].Index = (short)(nextPage.Rows[r].Index - _pageSize); |
| } |
| |
| columnIndex._pages[pagePos] = newPage; |
| if (columnIndex.PageCount + 1 > columnIndex._pages.Length) { |
| var pageTmp = new PageIndex[columnIndex._pages.Length << 1]; |
| Array.Copy(columnIndex._pages, 0, pageTmp, 0, columnIndex.PageCount); |
| columnIndex._pages = pageTmp; |
| } |
| Array.Copy( |
| columnIndex._pages, |
| pagePos + 1, |
| columnIndex._pages, |
| pagePos + 2, |
| columnIndex.PageCount - pagePos - 1); |
| columnIndex._pages[pagePos + 1] = nextPage; |
| page = nextPage; |
| //pos -= PageSize; |
| columnIndex.PageCount++; |
| return pagePos + 1; |
| } |
| |
| private PageIndex AdjustIndex(ColumnIndex columnIndex, int pagePos) { |
| PageIndex page = columnIndex._pages[pagePos]; |
| //First Adjust indexes |
| if (page.Offset + page.Rows[0].Index >= _pageSize |
| || page.Offset >= _pageSize |
| || page.Rows[0].Index >= _pageSize) { |
| page.Index++; |
| page.Offset -= _pageSize; |
| } else if (page.Offset + page.Rows[0].Index <= -_pageSize |
| || page.Offset <= -_pageSize |
| || page.Rows[0].Index <= -_pageSize) { |
| page.Index--; |
| page.Offset += _pageSize; |
| } |
| return page; |
| } |
| |
| private void AddPage(ColumnIndex column, int pos, short index) { |
| AddPage(column, pos); |
| column._pages[pos] = new() { |
| Index = index, |
| }; |
| if (pos > 0) { |
| var pp = column._pages[pos - 1]; |
| if (pp.RowCount > 0 && pp.Rows[pp.RowCount - 1].Index > _pageSize) { |
| column._pages[pos].Offset = pp.Rows[pp.RowCount - 1].Index - _pageSize; |
| } |
| } |
| } |
| |
| /// <summary> |
| /// Add a new page to the collection |
| /// </summary> |
| /// <param name="column">The column</param> |
| /// <param name="pos">Position</param> |
| /// <param name="page">The new page object to add</param> |
| private void AddPage(ColumnIndex column, int pos, PageIndex page) { |
| AddPage(column, pos); |
| column._pages[pos] = page; |
| } |
| |
| /// <summary> |
| /// Add a new page to the collection |
| /// </summary> |
| /// <param name="column">The column</param> |
| /// <param name="pos">Position</param> |
| private void AddPage(ColumnIndex column, int pos) { |
| if (column.PageCount == column._pages.Length) { |
| var pageTmp = new PageIndex[column._pages.Length * 2]; |
| Array.Copy(column._pages, 0, pageTmp, 0, column.PageCount); |
| column._pages = pageTmp; |
| } |
| if (pos < column.PageCount) { |
| Array.Copy(column._pages, pos, column._pages, pos + 1, column.PageCount - pos); |
| } |
| column.PageCount++; |
| } |
| |
| private void AddColumn(int pos, int column) { |
| if (ColumnCount == _columnIndex.Length) { |
| var colTmp = new ColumnIndex[_columnIndex.Length * 2]; |
| Array.Copy(_columnIndex, 0, colTmp, 0, ColumnCount); |
| _columnIndex = colTmp; |
| } |
| if (pos < ColumnCount) { |
| Array.Copy(_columnIndex, pos, _columnIndex, pos + 1, ColumnCount - pos); |
| } |
| _columnIndex[pos] = new() { |
| Index = (short)(column), |
| }; |
| ColumnCount++; |
| } |
| |
| private int _colPos = -1, |
| _row; |
| |
| public ulong Current => ((ulong)_row << 32) | (uint)(_columnIndex[_colPos].Index); |
| |
| //object IEnumerator.Current |
| //{ |
| // get |
| // { |
| // return GetValue(_row+1, _columnIndex[_colPos].Index); |
| // } |
| //} |
| public bool MoveNext() { |
| return GetNextCell(ref _row, ref _colPos, 0, ExcelPackage.MaxRows, ExcelPackage.MaxColumns); |
| } |
| |
| internal bool NextCell(ref int row, ref int col) { |
| return NextCell(ref row, ref col, 0, 0, ExcelPackage.MaxRows, ExcelPackage.MaxColumns); |
| } |
| |
| internal bool NextCell( |
| ref int row, |
| ref int col, |
| int minRow, |
| int minColPos, |
| int maxRow, |
| int maxColPos) { |
| if (minColPos >= ColumnCount) { |
| return false; |
| } |
| if (maxColPos >= ColumnCount) { |
| maxColPos = ColumnCount - 1; |
| } |
| var c = GetPosition(col); |
| if (c >= 0) { |
| if (c > maxColPos) { |
| if (col <= minColPos) { |
| return false; |
| } |
| col = minColPos; |
| return NextCell(ref row, ref col); |
| } |
| var r = GetNextCell(ref row, ref c, minColPos, maxRow, maxColPos); |
| col = _columnIndex[c].Index; |
| return r; |
| } |
| c = ~c; |
| if (c > _columnIndex[c].Index) { |
| if (col <= minColPos) { |
| return false; |
| } |
| col = minColPos; |
| return NextCell(ref row, ref col, minRow, minColPos, maxRow, maxColPos); |
| } |
| { |
| var r = GetNextCell(ref c, ref row, minColPos, maxRow, maxColPos); |
| col = _columnIndex[c].Index; |
| return r; |
| } |
| } |
| |
| internal bool GetNextCell( |
| ref int row, |
| ref int colPos, |
| int startColPos, |
| int endRow, |
| int endColPos) { |
| if (ColumnCount == 0) { |
| return false; |
| } |
| if (++colPos < ColumnCount && colPos <= endColPos) { |
| var r = _columnIndex[colPos].GetNextRow(row); |
| if (r |
| == row) //Exists next Row |
| { |
| return true; |
| } |
| int minRow, |
| minCol; |
| if (r > row) { |
| minRow = r; |
| minCol = colPos; |
| } else { |
| minRow = int.MaxValue; |
| minCol = 0; |
| } |
| |
| var c = colPos + 1; |
| while (c < ColumnCount && c <= endColPos) { |
| r = _columnIndex[c].GetNextRow(row); |
| if (r |
| == row) //Exists next Row |
| { |
| colPos = c; |
| return true; |
| } |
| if (r > row && r < minRow) { |
| minRow = r; |
| minCol = c; |
| } |
| c++; |
| } |
| c = startColPos; |
| if (row < endRow) { |
| row++; |
| while (c < colPos) { |
| r = _columnIndex[c].GetNextRow(row); |
| if (r |
| == row) //Exists next Row |
| { |
| colPos = c; |
| return true; |
| } |
| if (r > row && (r < minRow || (r == minRow && c < minCol)) && r <= endRow) { |
| minRow = r; |
| minCol = c; |
| } |
| c++; |
| } |
| } |
| |
| if (minRow == int.MaxValue || minRow > endRow) { |
| return false; |
| } |
| row = minRow; |
| colPos = minCol; |
| return true; |
| } |
| if (colPos <= startColPos || row >= endRow) { |
| return false; |
| } |
| colPos = startColPos - 1; |
| row++; |
| return GetNextCell(ref row, ref colPos, startColPos, endRow, endColPos); |
| } |
| |
| internal bool GetNextCell( |
| ref int row, |
| ref int colPos, |
| int startColPos, |
| int endRow, |
| int endColPos, |
| ref int[] pagePos, |
| ref int[] cellPos) { |
| if (colPos == endColPos) { |
| colPos = startColPos; |
| row++; |
| } else { |
| colPos++; |
| } |
| |
| if (pagePos[colPos] < 0) { |
| if (pagePos[colPos] == -1) { |
| pagePos[colPos] = _columnIndex[colPos].GetPosition(row); |
| } |
| } else if (_columnIndex[colPos]._pages[pagePos[colPos]].RowCount <= row) { |
| if (_columnIndex[colPos].PageCount > pagePos[colPos]) { |
| pagePos[colPos]++; |
| } else { |
| pagePos[colPos] = -2; |
| } |
| } |
| |
| var r = |
| _columnIndex[colPos]._pages[pagePos[colPos]].IndexOffset |
| + _columnIndex[colPos]._pages[pagePos[colPos]].Rows[cellPos[colPos]].Index; |
| if (r == row) { |
| row = r; |
| } |
| return true; |
| } |
| |
| internal bool PrevCell(ref int row, ref int col) { |
| return PrevCell(ref row, ref col, 0, 0, ExcelPackage.MaxRows, ExcelPackage.MaxColumns); |
| } |
| |
| internal bool PrevCell( |
| ref int row, |
| ref int col, |
| int minRow, |
| int minColPos, |
| int maxRow, |
| int maxColPos) { |
| if (minColPos >= ColumnCount) { |
| return false; |
| } |
| if (maxColPos >= ColumnCount) { |
| maxColPos = ColumnCount - 1; |
| } |
| var c = GetPosition(col); |
| if (c >= 0) { |
| if (c == 0) { |
| if (col >= maxColPos) { |
| return false; |
| } |
| if (row == minRow) { |
| return false; |
| } |
| row--; |
| col = maxColPos; |
| return PrevCell(ref row, ref col, minRow, minColPos, maxRow, maxColPos); |
| } |
| var ret = GetPrevCell(ref row, ref c, minRow, minColPos, maxColPos); |
| if (ret) { |
| col = _columnIndex[c].Index; |
| } |
| return ret; |
| } |
| c = ~c; |
| if (c == 0) { |
| if (col >= maxColPos || row <= 0) { |
| return false; |
| } |
| col = maxColPos; |
| row--; |
| return PrevCell(ref row, ref col, minRow, minColPos, maxRow, maxColPos); |
| } |
| { |
| var ret = GetPrevCell(ref row, ref c, minRow, minColPos, maxColPos); |
| if (ret) { |
| col = _columnIndex[c].Index; |
| } |
| return ret; |
| } |
| } |
| |
| internal bool GetPrevCell( |
| ref int row, |
| ref int colPos, |
| int startRow, |
| int startColPos, |
| int endColPos) { |
| if (ColumnCount == 0) { |
| return false; |
| } |
| if (--colPos >= startColPos) |
| // if (++colPos < ColumnCount && colPos <= endColPos) |
| { |
| var r = _columnIndex[colPos].GetNextRow(row); |
| if (r |
| == row) //Exists next Row |
| { |
| return true; |
| } |
| int minRow, |
| minCol; |
| if (r > row && r >= startRow) { |
| minRow = r; |
| minCol = colPos; |
| } else { |
| minRow = int.MaxValue; |
| minCol = 0; |
| } |
| |
| var c = colPos - 1; |
| if (c >= startColPos) { |
| while (c >= startColPos) { |
| r = _columnIndex[c].GetNextRow(row); |
| if (r |
| == row) //Exists next Row |
| { |
| colPos = c; |
| return true; |
| } |
| if (r > row && r < minRow && r >= startRow) { |
| minRow = r; |
| minCol = c; |
| } |
| c--; |
| } |
| } |
| if (row > startRow) { |
| c = endColPos; |
| row--; |
| while (c > colPos) { |
| r = _columnIndex[c].GetNextRow(row); |
| if (r |
| == row) //Exists next Row |
| { |
| colPos = c; |
| return true; |
| } |
| if (r > row && r < minRow && r >= startRow) { |
| minRow = r; |
| minCol = c; |
| } |
| c--; |
| } |
| } |
| if (minRow == int.MaxValue || startRow < minRow) { |
| return false; |
| } |
| row = minRow; |
| colPos = minCol; |
| return true; |
| } |
| colPos = ColumnCount; |
| row--; |
| if (row < startRow) { |
| Reset(); |
| return false; |
| } |
| return GetPrevCell(ref colPos, ref row, startRow, startColPos, endColPos); |
| } |
| |
| public void Reset() { |
| _colPos = -1; |
| _row = 0; |
| } |
| |
| //public IEnumerator<ulong> GetEnumerator() |
| //{ |
| // this.Reset(); |
| // return this; |
| //} |
| |
| //IEnumerator IEnumerable.GetEnumerator() |
| //{ |
| // this.Reset(); |
| // return this; |
| //} |
| } |
| |
| internal class CellsStoreEnumerator<T> : IEnumerable<T>, IEnumerator<T> { |
| private readonly CellStore<T> _cellStore; |
| private int row, |
| colPos; |
| private int[] pagePos, |
| cellPos; |
| private readonly int _startRow; |
| private readonly int _startCol; |
| private readonly int _endRow; |
| private readonly int _endCol; |
| private int minRow, |
| minColPos, |
| maxRow, |
| maxColPos; |
| |
| public CellsStoreEnumerator(CellStore<T> cellStore) |
| : this(cellStore, 0, 0, ExcelPackage.MaxRows, ExcelPackage.MaxColumns) {} |
| |
| public CellsStoreEnumerator( |
| CellStore<T> cellStore, |
| int startRow, |
| int startCol, |
| int endRow, |
| int endCol) { |
| _cellStore = cellStore; |
| |
| _startRow = startRow; |
| _startCol = startCol; |
| _endRow = endRow; |
| _endCol = endCol; |
| |
| Init(); |
| } |
| |
| internal void Init() { |
| minRow = _startRow; |
| maxRow = _endRow; |
| |
| minColPos = _cellStore.GetPosition(_startCol); |
| if (minColPos < 0) { |
| minColPos = ~minColPos; |
| } |
| maxColPos = _cellStore.GetPosition(_endCol); |
| if (maxColPos < 0) { |
| maxColPos = ~maxColPos - 1; |
| } |
| row = minRow; |
| colPos = minColPos - 1; |
| |
| var cols = maxColPos - minColPos + 1; |
| pagePos = new int[cols]; |
| cellPos = new int[cols]; |
| for (int i = 0; i < cols; i++) { |
| pagePos[i] = -1; |
| cellPos[i] = -1; |
| } |
| } |
| |
| internal int Row => row; |
| |
| internal int Column { |
| get { |
| if (colPos == -1) { |
| MoveNext(); |
| } |
| if (colPos == -1) { |
| return 0; |
| } |
| return _cellStore._columnIndex[colPos].Index; |
| } |
| } |
| |
| internal T Value { |
| get { |
| lock (_cellStore) { |
| return _cellStore.GetValue(row, Column); |
| } |
| } |
| set { |
| lock (_cellStore) { |
| _cellStore.SetValue(row, Column, value); |
| } |
| } |
| } |
| |
| internal bool Next() { |
| //return _cellStore.GetNextCell(ref row, ref colPos, minColPos, maxRow, maxColPos); |
| return _cellStore.GetNextCell(ref row, ref colPos, minColPos, maxRow, maxColPos); |
| } |
| |
| internal bool Previous() { |
| lock (_cellStore) { |
| return _cellStore.GetPrevCell(ref row, ref colPos, minRow, minColPos, maxColPos); |
| } |
| } |
| |
| public string CellAddress => ExcelCellBase.GetAddress(Row, Column); |
| |
| public IEnumerator<T> GetEnumerator() { |
| Reset(); |
| return this; |
| } |
| |
| IEnumerator IEnumerable.GetEnumerator() { |
| Reset(); |
| return this; |
| } |
| |
| public T Current => Value; |
| |
| public void Dispose() {} |
| |
| object IEnumerator.Current { |
| get { |
| Reset(); |
| return this; |
| } |
| } |
| |
| public bool MoveNext() { |
| return Next(); |
| } |
| |
| public void Reset() { |
| Init(); |
| } |
| } |
| |
| internal class FlagCellStore : CellStore<byte> { |
| internal void SetFlagValue(int row, int col, bool value, CellFlags cellFlags) { |
| CellFlags currentValue = (CellFlags)GetValue(row, col); |
| if (value) { |
| SetValue(row, col, (byte)(currentValue | cellFlags)); // add the CellFlag bit |
| } else { |
| SetValue(row, col, (byte)(currentValue & ~cellFlags)); // remove the CellFlag bit |
| } |
| } |
| |
| internal bool GetFlagValue(int row, int col, CellFlags cellFlags) { |
| return !(((byte)cellFlags & GetValue(row, col)) == 0); |
| } |
| } |
