< Summary

Class:GDX.DataTables.StableDataTable
Assembly:GDX
File(s):./Packages/com.dotbunny.gdx/GDX/DataTables/StableDataTable.cs
Covered lines:574
Uncovered lines:680
Coverable lines:1254
Total lines:2053
Line coverage:45.7% (574 of 1254)
Covered branches:0
Total branches:0
Covered methods:112
Total methods:169
Method coverage:66.2% (112 of 169)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
StableDataTable()0%110100%
GetDataVersion()0%2100%
GetStructureVersion()0%2100%
GetStructureCurrentVersion()0%2100%
Migrate(...)0%12300%
GetColumnCount()0%110100%
GetRowCount()0%110100%
GetAllRowDescriptions()0%4.044086.67%
GetRowDescription(...)0%2100%
GetRowDescriptionByOrder(...)0%110100%
GetColumnDescription(...)0%2100%
GetColumnDescriptionByOrder(...)0%110100%
GetAllColumnDescriptions()0%3.013088.89%
AssertColumnIdentifierValid(...)0%5.44055.56%
AssertRowIdentifierValid(...)0%7.195055.56%
SetColumnName(...)0%110100%
GetColumnName(...)0%110100%
SetRowName(...)0%110100%
GetRowName(...)0%110100%
GetRowNameRef(...)0%110100%
GetColumnNameRef(...)0%110100%
AddRow(...)0%15.6615085.71%
AddRows(...)0%4202000%
AddRows(...)0%4202000%
RemoveRow(...)0%6200%
AddColumn(...)0%32.0332097.06%
RemoveColumn(...)0%705.9731011.11%
SetString(...)0%110100%
SetBool(...)0%110100%
SetChar(...)0%110100%
SetSByte(...)0%110100%
SetByte(...)0%110100%
SetEnumInt(...)0%2100%
SetShort(...)0%110100%
SetUShort(...)0%110100%
SetInt(...)0%110100%
SetUInt(...)0%110100%
SetLong(...)0%110100%
SetULong(...)0%110100%
SetFloat(...)0%110100%
SetDouble(...)0%110100%
SetVector2(...)0%110100%
SetVector3(...)0%110100%
SetVector4(...)0%110100%
SetVector2Int(...)0%110100%
SetVector3Int(...)0%110100%
SetQuaternion(...)0%110100%
SetRect(...)0%110100%
SetRectInt(...)0%110100%
SetColor(...)0%110100%
SetLayerMask(...)0%110100%
SetBounds(...)0%110100%
SetBoundsInt(...)0%110100%
SetHash128(...)0%110100%
SetGradient(...)0%110100%
SetAnimationCurve(...)0%110100%
SetObject(...)0%110100%
SetTypeNameForColumn(...)0%12300%
GetTypeNameForColumn(...)0%12300%
GetString(...)0%110100%
GetBool(...)0%110100%
GetChar(...)0%110100%
GetEnumInt(...)0%2100%
GetSByte(...)0%110100%
GetByte(...)0%110100%
GetShort(...)0%110100%
GetUShort(...)0%110100%
GetInt(...)0%110100%
GetUInt(...)0%110100%
GetLong(...)0%110100%
GetULong(...)0%110100%
GetFloat(...)0%110100%
GetDouble(...)0%110100%
GetVector2(...)0%110100%
GetVector3(...)0%110100%
GetVector4(...)0%110100%
GetVector2Int(...)0%110100%
GetVector3Int(...)0%110100%
GetQuaternion(...)0%110100%
GetRect(...)0%110100%
GetRectInt(...)0%110100%
GetColor(...)0%110100%
GetLayerMask(...)0%110100%
GetBounds(...)0%110100%
GetBoundsInt(...)0%110100%
GetHash128(...)0%110100%
GetGradient(...)0%110100%
GetAnimationCurve(...)0%110100%
GetObject(...)0%110100%
GetStringRef(...)0%110100%
GetBoolRef(...)0%110100%
GetCharRef(...)0%110100%
GetSbyteRef(...)0%110100%
GetByteRef(...)0%110100%
GetShortRef(...)0%110100%
GetUshortRef(...)0%110100%
GetIntRef(...)0%110100%
GetUintRef(...)0%110100%
GetLongRef(...)0%110100%
GetUlongRef(...)0%110100%
GetFloatRef(...)0%110100%
GetDoubleRef(...)0%110100%
GetVector2Ref(...)0%110100%
GetVector3Ref(...)0%110100%
GetVector4Ref(...)0%110100%
GetVector2IntRef(...)0%110100%
GetVector3IntRef(...)0%110100%
GetQuaternionRef(...)0%110100%
GetRectRef(...)0%110100%
GetRectIntRef(...)0%110100%
GetColorRef(...)0%110100%
GetLayerMaskRef(...)0%110100%
GetBoundsRef(...)0%110100%
GetBoundsIntRef(...)0%110100%
GetHash128Ref(...)0%110100%
GetGradientRef(...)0%110100%
GetAnimationCurveRef(...)0%110100%
GetObjectRef(...)0%110100%
GetStringColumn(...)0%2100%
GetBoolColumn(...)0%2100%
GetCharColumn(...)0%2100%
GetSbyteColumn(...)0%2100%
GetByteColumn(...)0%2100%
GetShortColumn(...)0%2100%
GetUshortColumn(...)0%2100%
GetIntColumn(...)0%2100%
GetUintColumn(...)0%2100%
GetLongColumn(...)0%2100%
GetUlongColumn(...)0%2100%
GetFloatColumn(...)0%2100%
GetDoubleColumn(...)0%2100%
GetVector2Column(...)0%2100%
GetVector3Column(...)0%2100%
GetVector4Column(...)0%2100%
GetVector2IntColumn(...)0%2100%
GetVector3IntColumn(...)0%2100%
GetQuaternionColumn(...)0%2100%
GetRectColumn(...)0%2100%
GetRectIntColumn(...)0%2100%
GetColorColumn(...)0%2100%
GetLayerMaskColumn(...)0%2100%
GetBoundsColumn(...)0%2100%
GetBoundsIntColumn(...)0%2100%
GetHash128Column(...)0%2100%
GetGradientColumn(...)0%2100%
GetAnimationCurveColumn(...)0%2100%
GetObjectColumn(...)0%2100%
GetColumnOrder(...)0%2100%
SetColumnOrder(...)0%20400%
SetAllColumnOrders(...)0%6200%
GetRowOrder(...)0%2100%
SetRowOrder(...)0%20400%
SetAllRowOrders(...)0%30500%
ReSortRows[T](...)0%30500%
AddTypeNameEntry(...)0%330100%
RemoveTypeNameEntry(...)0%12300%
AddColumnInternal[T](...)0%23.1222086.76%
RemoveColumnInternal[T](...)0%4.054085%
InsertRowsOfTypeInternal[T](...)0%6.196082.61%
DeleteRowsOfTypeInternal[T](...)0%30500%
GetCellRef[T](...)0%110100%
GetCell[T](...)0%110100%
SetCell[T](...)0%110100%
GetColumn[T](...)0%2100%
SetRowOrderForColumns[T](...)0%56700%
AssertSortedColumnsArgValid(...)0%20400%
AssertColumnSortOrderValid(...)0%12300%
AssertRowSortOrderValid(...)0%12300%
AssertSortRowsArgValid(...)0%20400%

File(s)

./Packages/com.dotbunny.gdx/GDX/DataTables/StableDataTable.cs

#LineLine coverage
 1// Copyright (c) 2020-2024 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using GDX.Collections;
 7using UnityEngine;
 8using Object = UnityEngine.Object;
 9
 10namespace GDX.DataTables
 11{
 12    [HelpURL("https://gdx.dotbunny.com/manual/features/data-tables.html")]
 13    [CreateAssetMenu(menuName = "GDX/Stable Data Table", fileName = "GDXStableDataTable")]
 14    [Serializable]
 15    public class StableDataTable : DataTableBase
 16    {
 17#pragma warning disable IDE1006
 18        // ReSharper disable InconsistentNaming
 19
 20        [SerializeField] internal ArrayHolder<string>[] m_AllStringColumns;
 21        [SerializeField] internal ArrayHolder<bool>[] m_AllBoolColumns;
 22        [SerializeField] internal ArrayHolder<char>[] m_AllCharColumns;
 23        [SerializeField] internal ArrayHolder<sbyte>[] m_AllSByteColumns;
 24        [SerializeField] internal ArrayHolder<byte>[] m_AllByteColumns;
 25        [SerializeField] internal ArrayHolder<short>[] m_AllShortColumns;
 26        [SerializeField] internal ArrayHolder<ushort>[] m_AllUShortColumns;
 27        [SerializeField] internal ArrayHolder<int>[] m_AllIntColumns;
 28        [SerializeField] internal ArrayHolder<uint>[] m_AllUIntColumns;
 29        [SerializeField] internal ArrayHolder<long>[] m_AllLongColumns;
 30        [SerializeField] internal ArrayHolder<ulong>[] m_AllULongColumns;
 31        [SerializeField] internal ArrayHolder<float>[] m_AllFloatColumns;
 32        [SerializeField] internal ArrayHolder<double>[] m_AllDoubleColumns;
 33        [SerializeField] internal ArrayHolder<Vector2>[] m_AllVector2Columns;
 34        [SerializeField] internal ArrayHolder<Vector3>[] m_AllVector3Columns;
 35        [SerializeField] internal ArrayHolder<Vector4>[] m_AllVector4Columns;
 36        [SerializeField] internal ArrayHolder<Vector2Int>[] m_AllVector2IntColumns;
 37        [SerializeField] internal ArrayHolder<Vector3Int>[] m_AllVector3IntColumns;
 38        [SerializeField] internal ArrayHolder<Quaternion>[] m_AllQuaternionColumns;
 39        [SerializeField] internal ArrayHolder<Rect>[] m_AllRectColumns;
 40        [SerializeField] internal ArrayHolder<RectInt>[] m_AllRectIntColumns;
 41        [SerializeField] internal ArrayHolder<Color>[] m_AllColorColumns;
 42        [SerializeField] internal ArrayHolder<LayerMask>[] m_AllLayerMaskColumns;
 43        [SerializeField] internal ArrayHolder<Bounds>[] m_AllBoundsColumns;
 44        [SerializeField] internal ArrayHolder<BoundsInt>[] m_AllBoundsIntColumns;
 45        [SerializeField] internal ArrayHolder<Hash128>[] m_AllHash128Columns;
 46        [SerializeField] internal ArrayHolder<Gradient>[] m_AllGradientColumns;
 47        [SerializeField] internal ArrayHolder<AnimationCurve>[] m_AllAnimationCurveColumns;
 48        [SerializeField] internal ArrayHolder<Object>[] m_AllObjectRefColumns;
 49        [SerializeField] internal ArrayHolder<int>[] m_AllEnumIntColumns;
 50        [SerializeField] internal string[] m_AllObjectRefTypeNames;
 51        [SerializeField] internal string[] m_AllEnumIntTypeNames;
 52
 53        /// <summary>
 54        ///     Contains the name of each column of each type. Ordered by Serializable.SerializableTypes
 55        /// </summary>
 56        [SerializeField]
 1057        internal ArrayHolder<string>[] m_AllColumnNames = new ArrayHolder<string>[Serializable.SerializableTypesCount];
 58
 59        [SerializeField] internal int[] m_RowIdentifierToDenseIndexMap;
 60        [SerializeField] internal int[] m_RowDenseIndexToIDMap;
 61        [SerializeField] internal string[] m_RowNames;
 62        [SerializeField] internal int m_RowEntriesFreeListHead;
 63        [SerializeField] internal int m_RowCount;
 64        [SerializeField] internal ColumnEntry[] m_ColumnIdentifierToDenseIndexMap;
 65        [SerializeField] internal int[] m_ColumnIdentifierToSortOrderMap;
 66        [SerializeField] internal int[] m_SortedOrderToColumnIdentifierMap;
 67
 1068        [SerializeField] internal ArrayHolder<int>[] m_ColumnDenseIndexToIDMap =
 69            new ArrayHolder<int>[Serializable.SerializableTypesCount];
 70
 71        [SerializeField] internal int m_ColumnEntriesFreeListHead;
 72        [SerializeField] internal int m_CombinedColumnCount;
 1073        [SerializeField] internal ulong m_DataVersion = 1;
 74
 75        // ReSharper enable InconsistentNaming
 76#pragma warning restore IDE1006
 77
 78
 79        /// <summary>
 80        ///     Version of internal structure format.
 81        /// </summary>
 82        /// <remarks>Bump this if you make a change that requires resizing of arrays.</remarks>
 1083        [SerializeField] internal int m_StructureVersion = 1;
 84
 85        /// <inheritdoc />
 86        public override ulong GetDataVersion()
 087        {
 088            return m_DataVersion;
 089        }
 90
 91        /// <inheritdoc />
 92        public override int GetStructureVersion()
 093        {
 094            return m_StructureVersion;
 095        }
 96
 97        /// <inheritdoc />
 98        public override int GetStructureCurrentVersion()
 099        {
 0100            return 1;
 0101        }
 102
 103        public override bool Migrate(int currentVersion)
 0104        {
 0105            switch (m_StructureVersion)
 106            {
 107                case 0:
 108                    // Pre EnumInt
 0109                    if (currentVersion >= 0)
 0110                    {
 0111                        Array.Resize(ref m_AllColumnNames, 30);
 0112                        Array.Resize(ref m_ColumnDenseIndexToIDMap, 30);
 0113                    }
 114
 0115                    m_StructureVersion = currentVersion;
 0116                    break;
 117            }
 118
 0119            return m_StructureVersion == currentVersion;
 0120        }
 121
 122        /// <inheritdoc />
 123        public override int GetColumnCount()
 52124        {
 52125            return m_CombinedColumnCount;
 52126        }
 127
 128        /// <inheritdoc />
 129        public override int GetRowCount()
 36130        {
 36131            return m_RowCount;
 36132        }
 133
 134        /// <inheritdoc />
 135        public override RowDescription[] GetAllRowDescriptions()
 17136        {
 17137            if (m_CombinedColumnCount == 0 || m_RowCount == 0)
 1138            {
 1139                return null;
 140            }
 141
 16142            RowDescription[] returnArray = new RowDescription[m_RowCount];
 128143            for (int i = 0; i < m_RowCount; i++)
 48144            {
 48145                returnArray[i].Identifier = m_RowDenseIndexToIDMap[i];
 48146                returnArray[i].Name = m_RowNames[i];
 48147                returnArray[i].SortOrder = i;
 48148            }
 149
 16150            return returnArray;
 17151        }
 152
 153        /// <inheritdoc />
 154        public override RowDescription GetRowDescription(int rowIdentifier)
 0155        {
 0156            RowDescription returnRowDescription = new RowDescription();
 157
 0158            int rowDenseIndex = m_RowIdentifierToDenseIndexMap[rowIdentifier];
 159
 0160            returnRowDescription.Identifier = rowIdentifier;
 0161            returnRowDescription.Name = m_RowNames[rowDenseIndex];
 0162            returnRowDescription.SortOrder = rowDenseIndex;
 163
 0164            return returnRowDescription;
 0165        }
 166
 167        /// <inheritdoc />
 168        public override RowDescription GetRowDescriptionByOrder(int order)
 1169        {
 1170            return new RowDescription
 171            {
 172                Identifier = m_RowDenseIndexToIDMap[order], Name = m_RowNames[order], SortOrder = order
 173            };
 1174        }
 175
 176        /// <inheritdoc />
 177        public override ColumnDescription GetColumnDescription(int columnIdentifier)
 0178        {
 0179            ColumnDescription returnColumnDescription = new ColumnDescription();
 180
 0181            ref ColumnEntry columnEntry = ref m_ColumnIdentifierToDenseIndexMap[columnIdentifier];
 182
 0183            returnColumnDescription.Identifier = columnIdentifier;
 0184            returnColumnDescription.Name = m_AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 0185            returnColumnDescription.SortOrder = m_ColumnIdentifierToSortOrderMap[columnIdentifier];
 186
 0187            return returnColumnDescription;
 0188        }
 189
 190        /// <inheritdoc />
 191        public override ColumnDescription GetColumnDescriptionByOrder(int order)
 4192        {
 4193            int idAtOrderedIndex = m_SortedOrderToColumnIdentifierMap[order];
 4194            ref ColumnEntry columnEntry = ref m_ColumnIdentifierToDenseIndexMap[idAtOrderedIndex];
 195
 4196            string columnName = m_AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 197
 4198            return new ColumnDescription
 199            {
 200                Identifier = idAtOrderedIndex, Name = columnName, Type = columnEntry.ColumnType, SortOrder = order
 201            };
 4202        }
 203
 204        /// <inheritdoc />
 205        public override ColumnDescription[] GetAllColumnDescriptions()
 29206        {
 29207            if (m_CombinedColumnCount == 0)
 1208            {
 1209                return null;
 210            }
 211
 28212            ColumnDescription[] returnArray = new ColumnDescription[m_CombinedColumnCount];
 213
 298214            for (int i = 0; i < m_CombinedColumnCount; i++)
 121215            {
 121216                int columnID = m_SortedOrderToColumnIdentifierMap[i];
 121217                AssertColumnIdentifierValid(columnID);
 121218                ref ColumnEntry entryForID = ref m_ColumnIdentifierToDenseIndexMap[columnID];
 121219                ref ArrayHolder<string> nameColumnsForType = ref m_AllColumnNames[(int)entryForID.ColumnType];
 220
 121221                string name = nameColumnsForType[entryForID.ColumnDenseIndex];
 222
 121223                returnArray[i] = new ColumnDescription
 224                {
 225                    Name = name, Identifier = columnID, Type = entryForID.ColumnType, SortOrder = i
 226                };
 121227            }
 228
 28229            return returnArray;
 29230        }
 231
 232        internal void AssertColumnIdentifierValid(int columnID)
 1145233        {
 1145234            if (columnID < 0 || columnID >= m_ColumnIdentifierToDenseIndexMap.Length)
 0235            {
 0236                throw new ArgumentException("Invalid column outside valid ID range: " + columnID);
 237            }
 238
 1145239            ref ColumnEntry columnEntry = ref m_ColumnIdentifierToDenseIndexMap[columnID];
 240
 1145241            if (columnEntry.ColumnType == Serializable.SerializableTypes.Invalid)
 0242            {
 0243                throw new ArgumentException("Invalid column pointing to deallocated entry: " + columnID);
 244            }
 1145245        }
 246
 247        internal void AssertRowIdentifierValid(int rowID)
 921248        {
 921249            if (rowID < 0 || rowID >= m_RowIdentifierToDenseIndexMap.Length)
 0250            {
 0251                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 252            }
 253
 921254            int rowIndex = m_RowIdentifierToDenseIndexMap[rowID];
 255
 921256            if (rowIndex >= m_RowCount || rowIndex < 0)
 0257            {
 0258                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 259            }
 921260        }
 261
 262        /// <inheritdoc />
 263        public override void SetColumnName(int columnIdentifier, string columnName)
 30264        {
 30265            AssertColumnIdentifierValid(columnIdentifier);
 30266            ref ColumnEntry columnEntry = ref m_ColumnIdentifierToDenseIndexMap[columnIdentifier];
 30267            m_AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex] = columnName;
 30268        }
 269
 270        /// <inheritdoc />
 271        public override string GetColumnName(int columnIdentifier)
 60272        {
 60273            AssertColumnIdentifierValid(columnIdentifier);
 60274            ref ColumnEntry columnEntry = ref m_ColumnIdentifierToDenseIndexMap[columnIdentifier];
 60275            return m_AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 60276        }
 277
 278
 279        /// <inheritdoc />
 280        public override void SetRowName(int rowIdentifier, string rowName)
 10281        {
 10282            AssertRowIdentifierValid(rowIdentifier);
 10283            int rowDenseIndex = m_RowIdentifierToDenseIndexMap[rowIdentifier];
 10284            m_RowNames[rowDenseIndex] = rowName;
 10285        }
 286
 287        /// <inheritdoc />
 288        public override string GetRowName(int rowIdentifier)
 21289        {
 21290            AssertRowIdentifierValid(rowIdentifier);
 21291            int rowDenseIndex = m_RowIdentifierToDenseIndexMap[rowIdentifier];
 21292            return m_RowNames[rowDenseIndex];
 21293        }
 294
 295        public ref string GetRowNameRef(int rowIdentifier)
 20296        {
 20297            AssertRowIdentifierValid(rowIdentifier);
 20298            int rowDenseIndex = m_RowIdentifierToDenseIndexMap[rowIdentifier];
 20299            return ref m_RowNames[rowDenseIndex];
 20300        }
 301
 302        public ref string GetColumnNameRef(int columnIdentifier)
 60303        {
 60304            AssertColumnIdentifierValid(columnIdentifier);
 60305            ref ColumnEntry columnEntry = ref m_ColumnIdentifierToDenseIndexMap[columnIdentifier];
 60306            return ref m_AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 60307        }
 308
 309        /// <inheritdoc />
 310        public override int AddRow(string rowName = null, int insertAtRowIdentifier = -1)
 56311        {
 56312            if (insertAtRowIdentifier >= 0)
 0313            {
 0314                AssertRowIdentifierValid(insertAtRowIdentifier);
 0315            }
 316
 56317            int rowID = m_RowEntriesFreeListHead;
 56318            int rowIDToDenseIndexMapLength = m_RowIdentifierToDenseIndexMap?.Length ?? 0;
 56319            if (rowID >= rowIDToDenseIndexMapLength)
 21320            {
 21321                int newSize = rowID * 2;
 21322                newSize = newSize == 0 ? 1 : newSize;
 21323                Array.Resize(ref m_RowIdentifierToDenseIndexMap, newSize);
 188324                for (int i = rowID; i < newSize; i++)
 73325                {
 73326                    m_RowIdentifierToDenseIndexMap[i] = i + 1;
 73327                }
 21328            }
 329
 56330            int denseIndexToIDMapLength = m_RowDenseIndexToIDMap?.Length ?? 0;
 56331            Array.Resize(ref m_RowDenseIndexToIDMap, denseIndexToIDMapLength + 1);
 56332            Array.Resize(ref m_RowNames, denseIndexToIDMapLength + 1);
 333
 56334            int insertAt = insertAtRowIdentifier < 0
 335                ? m_RowCount
 336                : m_RowIdentifierToDenseIndexMap[insertAtRowIdentifier];
 337
 112338            for (int i = denseIndexToIDMapLength; i > insertAt; i--)
 0339            {
 0340                int currentRowID = m_RowDenseIndexToIDMap[i - 1];
 0341                m_RowDenseIndexToIDMap[i] = currentRowID;
 342
 0343                m_RowIdentifierToDenseIndexMap[currentRowID] = i;
 344
 0345                m_RowNames[i] = m_RowNames[i - 1];
 0346            }
 347
 56348            m_RowEntriesFreeListHead = m_RowIdentifierToDenseIndexMap[rowID];
 56349            m_RowIdentifierToDenseIndexMap[rowID] = insertAt;
 56350            m_RowDenseIndexToIDMap[insertAt] = rowID;
 56351            m_RowNames[insertAt] = rowName == null ? rowID.ToString() : rowName;
 352
 56353            InsertRowsOfTypeInternal(ref m_AllStringColumns, insertAt, 1);
 56354            InsertRowsOfTypeInternal(ref m_AllBoolColumns, insertAt, 1);
 56355            InsertRowsOfTypeInternal(ref m_AllCharColumns, insertAt, 1);
 56356            InsertRowsOfTypeInternal(ref m_AllSByteColumns, insertAt, 1);
 56357            InsertRowsOfTypeInternal(ref m_AllByteColumns, insertAt, 1);
 56358            InsertRowsOfTypeInternal(ref m_AllShortColumns, insertAt, 1);
 56359            InsertRowsOfTypeInternal(ref m_AllUShortColumns, insertAt, 1);
 56360            InsertRowsOfTypeInternal(ref m_AllIntColumns, insertAt, 1);
 56361            InsertRowsOfTypeInternal(ref m_AllUIntColumns, insertAt, 1);
 56362            InsertRowsOfTypeInternal(ref m_AllLongColumns, insertAt, 1);
 56363            InsertRowsOfTypeInternal(ref m_AllULongColumns, insertAt, 1);
 56364            InsertRowsOfTypeInternal(ref m_AllFloatColumns, insertAt, 1);
 56365            InsertRowsOfTypeInternal(ref m_AllDoubleColumns, insertAt, 1);
 56366            InsertRowsOfTypeInternal(ref m_AllVector2Columns, insertAt, 1);
 56367            InsertRowsOfTypeInternal(ref m_AllVector3Columns, insertAt, 1);
 56368            InsertRowsOfTypeInternal(ref m_AllVector4Columns, insertAt, 1);
 56369            InsertRowsOfTypeInternal(ref m_AllVector2IntColumns, insertAt, 1);
 56370            InsertRowsOfTypeInternal(ref m_AllVector3IntColumns, insertAt, 1);
 56371            InsertRowsOfTypeInternal(ref m_AllQuaternionColumns, insertAt, 1);
 56372            InsertRowsOfTypeInternal(ref m_AllRectColumns, insertAt, 1);
 56373            InsertRowsOfTypeInternal(ref m_AllRectIntColumns, insertAt, 1);
 56374            InsertRowsOfTypeInternal(ref m_AllColorColumns, insertAt, 1);
 56375            InsertRowsOfTypeInternal(ref m_AllLayerMaskColumns, insertAt, 1);
 56376            InsertRowsOfTypeInternal(ref m_AllBoundsColumns, insertAt, 1);
 56377            InsertRowsOfTypeInternal(ref m_AllBoundsIntColumns, insertAt, 1);
 56378            InsertRowsOfTypeInternal(ref m_AllHash128Columns, insertAt, 1);
 56379            InsertRowsOfTypeInternal(ref m_AllGradientColumns, insertAt, 1);
 56380            InsertRowsOfTypeInternal(ref m_AllAnimationCurveColumns, insertAt, 1);
 56381            InsertRowsOfTypeInternal(ref m_AllObjectRefColumns, insertAt, 1);
 56382            InsertRowsOfTypeInternal(ref m_AllEnumIntColumns, insertAt, 1);
 383
 56384            ++m_RowCount;
 56385            m_DataVersion++;
 386
 56387            return rowID;
 56388        }
 389
 390        public void AddRows(int numberOfNewRows, string[] rowNames = null, int insertAtRowID = -1)
 0391        {
 0392            if (insertAtRowID >= 0)
 0393            {
 0394                AssertRowIdentifierValid(insertAtRowID);
 0395            }
 396
 0397            int rowIDToDenseIndexMapLength = m_RowIdentifierToDenseIndexMap?.Length ?? 0;
 0398            int newCount = m_RowCount + numberOfNewRows;
 0399            if (newCount > rowIDToDenseIndexMapLength)
 0400            {
 0401                int newSize = newCount;
 0402                --newSize;
 0403                newSize |= newSize >> 1;
 0404                newSize |= newSize >> 2;
 0405                newSize |= newSize >> 4;
 0406                newSize |= newSize >> 8;
 0407                newSize |= newSize >> 16;
 0408                ++newSize;
 409
 0410                newSize = newSize == 0 ? 1 : newSize;
 0411                Array.Resize(ref m_RowIdentifierToDenseIndexMap, newSize);
 0412                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0413                {
 0414                    m_RowIdentifierToDenseIndexMap[i] = i + 1;
 0415                }
 0416            }
 417
 0418            int denseIndexToIDMapLength = m_RowDenseIndexToIDMap?.Length ?? 0;
 0419            Array.Resize(ref m_RowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 0420            Array.Resize(ref rowNames, denseIndexToIDMapLength + numberOfNewRows);
 421
 0422            int insertAt = insertAtRowID < 0 ? m_RowCount : m_RowIdentifierToDenseIndexMap[insertAtRowID];
 423
 0424            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0425            {
 0426                int currentRowID = m_RowDenseIndexToIDMap[i - numberOfNewRows];
 0427                m_RowDenseIndexToIDMap[i] = currentRowID;
 428
 0429                m_RowIdentifierToDenseIndexMap[currentRowID] = i;
 430
 0431                rowNames[i] = rowNames[i - numberOfNewRows];
 0432            }
 433
 0434            int freeListHead = m_RowEntriesFreeListHead;
 435
 0436            for (int i = 0; i < numberOfNewRows; i++)
 0437            {
 0438                int rowID = freeListHead;
 0439                freeListHead = m_RowIdentifierToDenseIndexMap[rowID];
 0440                m_RowIdentifierToDenseIndexMap[rowID] = insertAt + i;
 0441                m_RowDenseIndexToIDMap[insertAt + i] = rowID;
 0442            }
 443
 0444            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0445            string emptyString = string.Empty;
 0446            for (int i = 0; i < numberOfNewRowNames; i++)
 0447            {
 0448                string currentRowName = rowNames[i];
 0449                int rowIDAt = m_RowDenseIndexToIDMap[insertAt + i];
 0450                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0451            }
 452
 0453            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0454            {
 0455                int rowIDAt = m_RowDenseIndexToIDMap[insertAt + i];
 0456                rowNames[insertAt + i] = rowIDAt.ToString();
 0457            }
 458
 0459            m_RowEntriesFreeListHead = freeListHead;
 460
 0461            InsertRowsOfTypeInternal(ref m_AllStringColumns, insertAt, numberOfNewRows);
 0462            InsertRowsOfTypeInternal(ref m_AllBoolColumns, insertAt, numberOfNewRows);
 0463            InsertRowsOfTypeInternal(ref m_AllCharColumns, insertAt, numberOfNewRows);
 0464            InsertRowsOfTypeInternal(ref m_AllSByteColumns, insertAt, numberOfNewRows);
 0465            InsertRowsOfTypeInternal(ref m_AllByteColumns, insertAt, numberOfNewRows);
 0466            InsertRowsOfTypeInternal(ref m_AllShortColumns, insertAt, numberOfNewRows);
 0467            InsertRowsOfTypeInternal(ref m_AllUShortColumns, insertAt, numberOfNewRows);
 0468            InsertRowsOfTypeInternal(ref m_AllIntColumns, insertAt, numberOfNewRows);
 0469            InsertRowsOfTypeInternal(ref m_AllUIntColumns, insertAt, numberOfNewRows);
 0470            InsertRowsOfTypeInternal(ref m_AllLongColumns, insertAt, numberOfNewRows);
 0471            InsertRowsOfTypeInternal(ref m_AllULongColumns, insertAt, numberOfNewRows);
 0472            InsertRowsOfTypeInternal(ref m_AllFloatColumns, insertAt, numberOfNewRows);
 0473            InsertRowsOfTypeInternal(ref m_AllDoubleColumns, insertAt, numberOfNewRows);
 0474            InsertRowsOfTypeInternal(ref m_AllVector2Columns, insertAt, numberOfNewRows);
 0475            InsertRowsOfTypeInternal(ref m_AllVector3Columns, insertAt, numberOfNewRows);
 0476            InsertRowsOfTypeInternal(ref m_AllVector4Columns, insertAt, numberOfNewRows);
 0477            InsertRowsOfTypeInternal(ref m_AllVector2IntColumns, insertAt, numberOfNewRows);
 0478            InsertRowsOfTypeInternal(ref m_AllVector3IntColumns, insertAt, numberOfNewRows);
 0479            InsertRowsOfTypeInternal(ref m_AllQuaternionColumns, insertAt, numberOfNewRows);
 0480            InsertRowsOfTypeInternal(ref m_AllRectColumns, insertAt, numberOfNewRows);
 0481            InsertRowsOfTypeInternal(ref m_AllRectIntColumns, insertAt, numberOfNewRows);
 0482            InsertRowsOfTypeInternal(ref m_AllColorColumns, insertAt, numberOfNewRows);
 0483            InsertRowsOfTypeInternal(ref m_AllLayerMaskColumns, insertAt, numberOfNewRows);
 0484            InsertRowsOfTypeInternal(ref m_AllBoundsColumns, insertAt, numberOfNewRows);
 0485            InsertRowsOfTypeInternal(ref m_AllBoundsIntColumns, insertAt, numberOfNewRows);
 0486            InsertRowsOfTypeInternal(ref m_AllHash128Columns, insertAt, numberOfNewRows);
 0487            InsertRowsOfTypeInternal(ref m_AllGradientColumns, insertAt, numberOfNewRows);
 0488            InsertRowsOfTypeInternal(ref m_AllAnimationCurveColumns, insertAt, numberOfNewRows);
 0489            InsertRowsOfTypeInternal(ref m_AllObjectRefColumns, insertAt, numberOfNewRows);
 0490            InsertRowsOfTypeInternal(ref m_AllEnumIntColumns, insertAt, numberOfNewRows);
 491
 0492            m_RowCount += numberOfNewRows;
 0493            m_DataVersion++;
 0494        }
 495
 496        public void AddRows(int numberOfNewRows, ref int[] rowIDs, string[] rowNames = null, int insertAtRowID = -1)
 0497        {
 0498            if (insertAtRowID >= 0)
 0499            {
 0500                AssertRowIdentifierValid(insertAtRowID);
 0501            }
 502
 0503            int rowIDToDenseIndexMapLength = m_RowIdentifierToDenseIndexMap?.Length ?? 0;
 0504            int newCount = m_RowCount + numberOfNewRows;
 0505            if (newCount > rowIDToDenseIndexMapLength)
 0506            {
 0507                int newSize = newCount;
 0508                --newSize;
 0509                newSize |= newSize >> 1;
 0510                newSize |= newSize >> 2;
 0511                newSize |= newSize >> 4;
 0512                newSize |= newSize >> 8;
 0513                newSize |= newSize >> 16;
 0514                ++newSize;
 515
 0516                newSize = newSize == 0 ? 1 : newSize;
 0517                Array.Resize(ref m_RowIdentifierToDenseIndexMap, newSize);
 0518                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0519                {
 0520                    m_RowIdentifierToDenseIndexMap[i] = i + 1;
 0521                }
 0522            }
 523
 0524            int denseIndexToIDMapLength = m_RowDenseIndexToIDMap?.Length ?? 0;
 0525            Array.Resize(ref m_RowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 526
 0527            int insertAt = insertAtRowID < 0 ? m_RowCount : m_RowIdentifierToDenseIndexMap[insertAtRowID];
 528
 0529            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0530            {
 0531                int currentRowID = m_RowDenseIndexToIDMap[i - numberOfNewRows];
 0532                m_RowDenseIndexToIDMap[i] = currentRowID;
 533
 0534                m_RowIdentifierToDenseIndexMap[currentRowID] = i;
 535
 0536                rowNames[i] = rowNames[i - numberOfNewRows];
 0537            }
 538
 0539            int freeListHead = m_RowEntriesFreeListHead;
 540
 0541            for (int i = 0; i < numberOfNewRows; i++)
 0542            {
 0543                int rowID = freeListHead;
 0544                freeListHead = m_RowIdentifierToDenseIndexMap[rowID];
 0545                m_RowIdentifierToDenseIndexMap[rowID] = insertAt + i;
 0546                m_RowDenseIndexToIDMap[insertAt + i] = rowID;
 0547                rowIDs[i] = rowID;
 0548            }
 549
 0550            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0551            for (int i = 0; i < numberOfNewRowNames; i++)
 0552            {
 0553                string currentRowName = rowNames[i];
 0554                int rowIDAt = m_RowDenseIndexToIDMap[insertAt + i];
 0555                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0556            }
 557
 0558            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0559            {
 0560                int rowIDAt = m_RowDenseIndexToIDMap[insertAt + i];
 0561                rowNames[insertAt + i] = rowIDAt.ToString();
 0562            }
 563
 0564            m_RowEntriesFreeListHead = freeListHead;
 565
 0566            InsertRowsOfTypeInternal(ref m_AllStringColumns, insertAt, numberOfNewRows);
 0567            InsertRowsOfTypeInternal(ref m_AllBoolColumns, insertAt, numberOfNewRows);
 0568            InsertRowsOfTypeInternal(ref m_AllCharColumns, insertAt, numberOfNewRows);
 0569            InsertRowsOfTypeInternal(ref m_AllSByteColumns, insertAt, numberOfNewRows);
 0570            InsertRowsOfTypeInternal(ref m_AllByteColumns, insertAt, numberOfNewRows);
 0571            InsertRowsOfTypeInternal(ref m_AllShortColumns, insertAt, numberOfNewRows);
 0572            InsertRowsOfTypeInternal(ref m_AllUShortColumns, insertAt, numberOfNewRows);
 0573            InsertRowsOfTypeInternal(ref m_AllIntColumns, insertAt, numberOfNewRows);
 0574            InsertRowsOfTypeInternal(ref m_AllUIntColumns, insertAt, numberOfNewRows);
 0575            InsertRowsOfTypeInternal(ref m_AllLongColumns, insertAt, numberOfNewRows);
 0576            InsertRowsOfTypeInternal(ref m_AllULongColumns, insertAt, numberOfNewRows);
 0577            InsertRowsOfTypeInternal(ref m_AllFloatColumns, insertAt, numberOfNewRows);
 0578            InsertRowsOfTypeInternal(ref m_AllDoubleColumns, insertAt, numberOfNewRows);
 0579            InsertRowsOfTypeInternal(ref m_AllVector2Columns, insertAt, numberOfNewRows);
 0580            InsertRowsOfTypeInternal(ref m_AllVector3Columns, insertAt, numberOfNewRows);
 0581            InsertRowsOfTypeInternal(ref m_AllVector4Columns, insertAt, numberOfNewRows);
 0582            InsertRowsOfTypeInternal(ref m_AllVector2IntColumns, insertAt, numberOfNewRows);
 0583            InsertRowsOfTypeInternal(ref m_AllVector3IntColumns, insertAt, numberOfNewRows);
 0584            InsertRowsOfTypeInternal(ref m_AllQuaternionColumns, insertAt, numberOfNewRows);
 0585            InsertRowsOfTypeInternal(ref m_AllRectColumns, insertAt, numberOfNewRows);
 0586            InsertRowsOfTypeInternal(ref m_AllRectIntColumns, insertAt, numberOfNewRows);
 0587            InsertRowsOfTypeInternal(ref m_AllColorColumns, insertAt, numberOfNewRows);
 0588            InsertRowsOfTypeInternal(ref m_AllLayerMaskColumns, insertAt, numberOfNewRows);
 0589            InsertRowsOfTypeInternal(ref m_AllBoundsColumns, insertAt, numberOfNewRows);
 0590            InsertRowsOfTypeInternal(ref m_AllBoundsIntColumns, insertAt, numberOfNewRows);
 0591            InsertRowsOfTypeInternal(ref m_AllHash128Columns, insertAt, numberOfNewRows);
 0592            InsertRowsOfTypeInternal(ref m_AllGradientColumns, insertAt, numberOfNewRows);
 0593            InsertRowsOfTypeInternal(ref m_AllAnimationCurveColumns, insertAt, numberOfNewRows);
 0594            InsertRowsOfTypeInternal(ref m_AllObjectRefColumns, insertAt, numberOfNewRows);
 0595            InsertRowsOfTypeInternal(ref m_AllEnumIntColumns, insertAt, numberOfNewRows);
 596
 0597            m_RowCount += numberOfNewRows;
 0598            m_DataVersion++;
 0599        }
 600
 601        /// <inheritdoc />
 602        public override void RemoveRow(int rowIdentifier)
 0603        {
 0604            AssertRowIdentifierValid(rowIdentifier);
 0605            int rowDenseIndex = m_RowIdentifierToDenseIndexMap[rowIdentifier];
 0606            for (int i = rowDenseIndex + 1; i < m_RowCount; i++)
 0607            {
 0608                int currentRowID = m_RowDenseIndexToIDMap[i];
 0609                m_RowIdentifierToDenseIndexMap[currentRowID] = i - 1;
 0610                m_RowDenseIndexToIDMap[i - 1] = currentRowID;
 0611                m_RowNames[i - 1] = m_RowNames[i];
 0612            }
 613
 0614            m_RowIdentifierToDenseIndexMap[rowIdentifier] = m_RowEntriesFreeListHead;
 0615            m_RowEntriesFreeListHead = rowIdentifier;
 0616            Array.Resize(ref m_RowDenseIndexToIDMap, m_RowCount - 1);
 0617            Array.Resize(ref m_RowNames, m_RowCount - 1);
 618
 0619            DeleteRowsOfTypeInternal(ref m_AllStringColumns, rowDenseIndex, 1);
 0620            DeleteRowsOfTypeInternal(ref m_AllBoolColumns, rowDenseIndex, 1);
 0621            DeleteRowsOfTypeInternal(ref m_AllCharColumns, rowDenseIndex, 1);
 0622            DeleteRowsOfTypeInternal(ref m_AllSByteColumns, rowDenseIndex, 1);
 0623            DeleteRowsOfTypeInternal(ref m_AllByteColumns, rowDenseIndex, 1);
 0624            DeleteRowsOfTypeInternal(ref m_AllShortColumns, rowDenseIndex, 1);
 0625            DeleteRowsOfTypeInternal(ref m_AllUShortColumns, rowDenseIndex, 1);
 0626            DeleteRowsOfTypeInternal(ref m_AllIntColumns, rowDenseIndex, 1);
 0627            DeleteRowsOfTypeInternal(ref m_AllUIntColumns, rowDenseIndex, 1);
 0628            DeleteRowsOfTypeInternal(ref m_AllLongColumns, rowDenseIndex, 1);
 0629            DeleteRowsOfTypeInternal(ref m_AllULongColumns, rowDenseIndex, 1);
 0630            DeleteRowsOfTypeInternal(ref m_AllFloatColumns, rowDenseIndex, 1);
 0631            DeleteRowsOfTypeInternal(ref m_AllDoubleColumns, rowDenseIndex, 1);
 0632            DeleteRowsOfTypeInternal(ref m_AllVector2Columns, rowDenseIndex, 1);
 0633            DeleteRowsOfTypeInternal(ref m_AllVector3Columns, rowDenseIndex, 1);
 0634            DeleteRowsOfTypeInternal(ref m_AllVector4Columns, rowDenseIndex, 1);
 0635            DeleteRowsOfTypeInternal(ref m_AllVector2IntColumns, rowDenseIndex, 1);
 0636            DeleteRowsOfTypeInternal(ref m_AllVector3IntColumns, rowDenseIndex, 1);
 0637            DeleteRowsOfTypeInternal(ref m_AllQuaternionColumns, rowDenseIndex, 1);
 0638            DeleteRowsOfTypeInternal(ref m_AllRectColumns, rowDenseIndex, 1);
 0639            DeleteRowsOfTypeInternal(ref m_AllRectIntColumns, rowDenseIndex, 1);
 0640            DeleteRowsOfTypeInternal(ref m_AllColorColumns, rowDenseIndex, 1);
 0641            DeleteRowsOfTypeInternal(ref m_AllLayerMaskColumns, rowDenseIndex, 1);
 0642            DeleteRowsOfTypeInternal(ref m_AllBoundsColumns, rowDenseIndex, 1);
 0643            DeleteRowsOfTypeInternal(ref m_AllBoundsIntColumns, rowDenseIndex, 1);
 0644            DeleteRowsOfTypeInternal(ref m_AllHash128Columns, rowDenseIndex, 1);
 0645            DeleteRowsOfTypeInternal(ref m_AllGradientColumns, rowDenseIndex, 1);
 0646            DeleteRowsOfTypeInternal(ref m_AllAnimationCurveColumns, rowDenseIndex, 1);
 0647            DeleteRowsOfTypeInternal(ref m_AllObjectRefColumns, rowDenseIndex, 1);
 0648            DeleteRowsOfTypeInternal(ref m_AllEnumIntColumns, rowDenseIndex, 1);
 649
 0650            --m_RowCount;
 0651            m_DataVersion++;
 0652        }
 653
 654        /// <inheritdoc />
 655        public override int AddColumn(Serializable.SerializableTypes columnType, string columnName,
 656            int insertAtColumnIdentifier = -1)
 114657        {
 114658            switch (columnType)
 659            {
 660                case Serializable.SerializableTypes.String:
 13661                    return AddColumnInternal(columnName, ref m_AllStringColumns, Serializable.SerializableTypes.String,
 662                        insertAtColumnIdentifier);
 663                case Serializable.SerializableTypes.Char:
 3664                    return AddColumnInternal(columnName, ref m_AllCharColumns, Serializable.SerializableTypes.Char,
 665                        insertAtColumnIdentifier);
 666                case Serializable.SerializableTypes.Bool:
 4667                    return AddColumnInternal(columnName, ref m_AllBoolColumns, Serializable.SerializableTypes.Bool,
 668                        insertAtColumnIdentifier);
 669                case Serializable.SerializableTypes.SByte:
 4670                    return AddColumnInternal(columnName, ref m_AllSByteColumns, Serializable.SerializableTypes.SByte,
 671                        insertAtColumnIdentifier);
 672                case Serializable.SerializableTypes.Byte:
 3673                    return AddColumnInternal(columnName, ref m_AllByteColumns, Serializable.SerializableTypes.Byte,
 674                        insertAtColumnIdentifier);
 675                case Serializable.SerializableTypes.Short:
 3676                    return AddColumnInternal(columnName, ref m_AllShortColumns, Serializable.SerializableTypes.Short,
 677                        insertAtColumnIdentifier);
 678                case Serializable.SerializableTypes.UShort:
 3679                    return AddColumnInternal(columnName, ref m_AllUShortColumns, Serializable.SerializableTypes.UShort,
 680                        insertAtColumnIdentifier);
 681                case Serializable.SerializableTypes.Int:
 3682                    return AddColumnInternal(columnName, ref m_AllIntColumns, Serializable.SerializableTypes.Int,
 683                        insertAtColumnIdentifier);
 684                case Serializable.SerializableTypes.UInt:
 3685                    return AddColumnInternal(columnName, ref m_AllUIntColumns, Serializable.SerializableTypes.UInt,
 686                        insertAtColumnIdentifier);
 687                case Serializable.SerializableTypes.Long:
 3688                    return AddColumnInternal(columnName, ref m_AllLongColumns, Serializable.SerializableTypes.Long,
 689                        insertAtColumnIdentifier);
 690                case Serializable.SerializableTypes.ULong:
 3691                    return AddColumnInternal(columnName, ref m_AllULongColumns, Serializable.SerializableTypes.ULong,
 692                        insertAtColumnIdentifier);
 693                case Serializable.SerializableTypes.Float:
 4694                    return AddColumnInternal(columnName, ref m_AllFloatColumns, Serializable.SerializableTypes.Float,
 695                        insertAtColumnIdentifier);
 696                case Serializable.SerializableTypes.Double:
 4697                    return AddColumnInternal(columnName, ref m_AllDoubleColumns, Serializable.SerializableTypes.Double,
 698                        insertAtColumnIdentifier);
 699                case Serializable.SerializableTypes.Vector2:
 5700                    return AddColumnInternal(columnName, ref m_AllVector2Columns,
 701                        Serializable.SerializableTypes.Vector2,
 702                        insertAtColumnIdentifier);
 703                case Serializable.SerializableTypes.Vector3:
 3704                    return AddColumnInternal(columnName, ref m_AllVector3Columns,
 705                        Serializable.SerializableTypes.Vector3,
 706                        insertAtColumnIdentifier);
 707                case Serializable.SerializableTypes.Vector4:
 3708                    return AddColumnInternal(columnName, ref m_AllVector4Columns,
 709                        Serializable.SerializableTypes.Vector4,
 710                        insertAtColumnIdentifier);
 711                case Serializable.SerializableTypes.Vector2Int:
 3712                    return AddColumnInternal(columnName, ref m_AllVector2IntColumns,
 713                        Serializable.SerializableTypes.Vector2Int, insertAtColumnIdentifier);
 714                case Serializable.SerializableTypes.Vector3Int:
 3715                    return AddColumnInternal(columnName, ref m_AllVector3IntColumns,
 716                        Serializable.SerializableTypes.Vector3Int, insertAtColumnIdentifier);
 717                case Serializable.SerializableTypes.Quaternion:
 4718                    return AddColumnInternal(columnName, ref m_AllQuaternionColumns,
 719                        Serializable.SerializableTypes.Quaternion, insertAtColumnIdentifier);
 720                case Serializable.SerializableTypes.Rect:
 3721                    return AddColumnInternal(columnName, ref m_AllRectColumns, Serializable.SerializableTypes.Rect,
 722                        insertAtColumnIdentifier);
 723                case Serializable.SerializableTypes.RectInt:
 3724                    return AddColumnInternal(columnName, ref m_AllRectIntColumns,
 725                        Serializable.SerializableTypes.RectInt,
 726                        insertAtColumnIdentifier);
 727                case Serializable.SerializableTypes.Color:
 3728                    return AddColumnInternal(columnName, ref m_AllColorColumns, Serializable.SerializableTypes.Color,
 729                        insertAtColumnIdentifier);
 730                case Serializable.SerializableTypes.LayerMask:
 3731                    return AddColumnInternal(columnName, ref m_AllLayerMaskColumns,
 732                        Serializable.SerializableTypes.LayerMask, insertAtColumnIdentifier);
 733                case Serializable.SerializableTypes.Bounds:
 9734                    return AddColumnInternal(columnName, ref m_AllBoundsColumns, Serializable.SerializableTypes.Bounds,
 735                        insertAtColumnIdentifier);
 736                case Serializable.SerializableTypes.BoundsInt:
 3737                    return AddColumnInternal(columnName, ref m_AllBoundsIntColumns,
 738                        Serializable.SerializableTypes.BoundsInt, insertAtColumnIdentifier);
 739                case Serializable.SerializableTypes.Hash128:
 3740                    return AddColumnInternal(columnName, ref m_AllHash128Columns,
 741                        Serializable.SerializableTypes.Hash128,
 742                        insertAtColumnIdentifier);
 743                case Serializable.SerializableTypes.Gradient:
 3744                    return AddColumnInternal(columnName, ref m_AllGradientColumns,
 745                        Serializable.SerializableTypes.Gradient, insertAtColumnIdentifier);
 746                case Serializable.SerializableTypes.AnimationCurve:
 3747                    return AddColumnInternal(columnName, ref m_AllAnimationCurveColumns,
 748                        Serializable.SerializableTypes.AnimationCurve, insertAtColumnIdentifier);
 749                case Serializable.SerializableTypes.Object:
 4750                    return AddColumnInternal(columnName, ref m_AllObjectRefColumns,
 751                        Serializable.SerializableTypes.Object,
 752                        insertAtColumnIdentifier);
 753                case Serializable.SerializableTypes.EnumInt:
 3754                    return AddColumnInternal(columnName, ref m_AllEnumIntColumns,
 755                        Serializable.SerializableTypes.EnumInt,
 756                        insertAtColumnIdentifier);
 757            }
 758
 0759            return -1;
 114760        }
 761
 762        /// <inheritdoc />
 763        public override void RemoveColumn(Serializable.SerializableTypes columnType, int columnIdentifier)
 4764        {
 4765            switch (columnType)
 766            {
 767                case Serializable.SerializableTypes.String:
 1768                    RemoveColumnInternal(ref m_AllStringColumns, Serializable.SerializableTypes.String,
 769                        columnIdentifier);
 1770                    break;
 771                case Serializable.SerializableTypes.Char:
 0772                    RemoveColumnInternal(ref m_AllCharColumns, Serializable.SerializableTypes.Char, columnIdentifier);
 0773                    break;
 774                case Serializable.SerializableTypes.Bool:
 0775                    RemoveColumnInternal(ref m_AllBoolColumns, Serializable.SerializableTypes.Bool, columnIdentifier);
 0776                    break;
 777                case Serializable.SerializableTypes.SByte:
 0778                    RemoveColumnInternal(ref m_AllSByteColumns, Serializable.SerializableTypes.SByte, columnIdentifier);
 0779                    break;
 780                case Serializable.SerializableTypes.Byte:
 0781                    RemoveColumnInternal(ref m_AllByteColumns, Serializable.SerializableTypes.Byte, columnIdentifier);
 0782                    break;
 783                case Serializable.SerializableTypes.Short:
 0784                    RemoveColumnInternal(ref m_AllShortColumns, Serializable.SerializableTypes.Short, columnIdentifier);
 0785                    break;
 786                case Serializable.SerializableTypes.UShort:
 0787                    RemoveColumnInternal(ref m_AllUShortColumns, Serializable.SerializableTypes.UShort,
 788                        columnIdentifier);
 0789                    break;
 790                case Serializable.SerializableTypes.Int:
 0791                    RemoveColumnInternal(ref m_AllIntColumns, Serializable.SerializableTypes.Int, columnIdentifier);
 0792                    break;
 793                case Serializable.SerializableTypes.UInt:
 0794                    RemoveColumnInternal(ref m_AllUIntColumns, Serializable.SerializableTypes.UInt, columnIdentifier);
 0795                    break;
 796                case Serializable.SerializableTypes.Long:
 0797                    RemoveColumnInternal(ref m_AllLongColumns, Serializable.SerializableTypes.Long, columnIdentifier);
 0798                    break;
 799                case Serializable.SerializableTypes.ULong:
 0800                    RemoveColumnInternal(ref m_AllULongColumns, Serializable.SerializableTypes.ULong, columnIdentifier);
 0801                    break;
 802                case Serializable.SerializableTypes.Float:
 0803                    RemoveColumnInternal(ref m_AllFloatColumns, Serializable.SerializableTypes.Float, columnIdentifier);
 0804                    break;
 805                case Serializable.SerializableTypes.Double:
 0806                    RemoveColumnInternal(ref m_AllDoubleColumns, Serializable.SerializableTypes.Double,
 807                        columnIdentifier);
 0808                    break;
 809                case Serializable.SerializableTypes.Vector2:
 0810                    RemoveColumnInternal(ref m_AllVector2Columns, Serializable.SerializableTypes.Vector2,
 811                        columnIdentifier);
 0812                    break;
 813                case Serializable.SerializableTypes.Vector3:
 0814                    RemoveColumnInternal(ref m_AllVector3Columns, Serializable.SerializableTypes.Vector3,
 815                        columnIdentifier);
 0816                    break;
 817                case Serializable.SerializableTypes.Vector4:
 0818                    RemoveColumnInternal(ref m_AllVector4Columns, Serializable.SerializableTypes.Vector4,
 819                        columnIdentifier);
 0820                    break;
 821                case Serializable.SerializableTypes.Vector2Int:
 0822                    RemoveColumnInternal(ref m_AllVector2IntColumns, Serializable.SerializableTypes.Vector2Int,
 823                        columnIdentifier);
 0824                    break;
 825                case Serializable.SerializableTypes.Vector3Int:
 0826                    RemoveColumnInternal(ref m_AllVector3IntColumns, Serializable.SerializableTypes.Vector3Int,
 827                        columnIdentifier);
 0828                    break;
 829                case Serializable.SerializableTypes.Quaternion:
 0830                    RemoveColumnInternal(ref m_AllQuaternionColumns, Serializable.SerializableTypes.Quaternion,
 831                        columnIdentifier);
 0832                    break;
 833                case Serializable.SerializableTypes.Rect:
 0834                    RemoveColumnInternal(ref m_AllRectColumns, Serializable.SerializableTypes.Rect, columnIdentifier);
 0835                    break;
 836                case Serializable.SerializableTypes.RectInt:
 0837                    RemoveColumnInternal(ref m_AllRectIntColumns, Serializable.SerializableTypes.RectInt,
 838                        columnIdentifier);
 0839                    break;
 840                case Serializable.SerializableTypes.Color:
 0841                    RemoveColumnInternal(ref m_AllColorColumns, Serializable.SerializableTypes.Color, columnIdentifier);
 0842                    break;
 843                case Serializable.SerializableTypes.LayerMask:
 0844                    RemoveColumnInternal(ref m_AllLayerMaskColumns, Serializable.SerializableTypes.LayerMask,
 845                        columnIdentifier);
 0846                    break;
 847                case Serializable.SerializableTypes.Bounds:
 3848                    RemoveColumnInternal(ref m_AllBoundsColumns, Serializable.SerializableTypes.Bounds,
 849                        columnIdentifier);
 3850                    break;
 851                case Serializable.SerializableTypes.BoundsInt:
 0852                    RemoveColumnInternal(ref m_AllBoundsIntColumns, Serializable.SerializableTypes.BoundsInt,
 853                        columnIdentifier);
 0854                    break;
 855                case Serializable.SerializableTypes.Hash128:
 0856                    RemoveColumnInternal(ref m_AllHash128Columns, Serializable.SerializableTypes.Hash128,
 857                        columnIdentifier);
 0858                    break;
 859                case Serializable.SerializableTypes.Gradient:
 0860                    RemoveColumnInternal(ref m_AllGradientColumns, Serializable.SerializableTypes.Gradient,
 861                        columnIdentifier);
 0862                    break;
 863                case Serializable.SerializableTypes.AnimationCurve:
 0864                    RemoveColumnInternal(ref m_AllAnimationCurveColumns, Serializable.SerializableTypes.AnimationCurve,
 865                        columnIdentifier);
 0866                    break;
 867                case Serializable.SerializableTypes.Object:
 0868                    RemoveColumnInternal(ref m_AllObjectRefColumns, Serializable.SerializableTypes.Object,
 869                        columnIdentifier);
 0870                    break;
 871                case Serializable.SerializableTypes.EnumInt:
 0872                    RemoveColumnInternal(ref m_AllEnumIntColumns, Serializable.SerializableTypes.EnumInt,
 873                        columnIdentifier);
 0874                    break;
 875            }
 4876        }
 877
 878        // Set
 879        /// <inheritdoc />
 880        public override ulong SetString(int rowIdentifier, int columnIdentifier, string newValue)
 10881        {
 10882            return SetCell(rowIdentifier, columnIdentifier, ref m_AllStringColumns, newValue);
 10883        }
 884
 885        /// <inheritdoc />
 886        public override ulong SetBool(int rowIdentifier, int columnIdentifier, bool newValue)
 10887        {
 10888            return SetCell(rowIdentifier, columnIdentifier, ref m_AllBoolColumns, newValue);
 10889        }
 890
 891        /// <inheritdoc />
 892        public override ulong SetChar(int rowIdentifier, int columnIdentifier, char newValue)
 10893        {
 10894            return SetCell(rowIdentifier, columnIdentifier, ref m_AllCharColumns, newValue);
 10895        }
 896
 897        /// <inheritdoc />
 898        public override ulong SetSByte(int rowIdentifier, int columnIdentifier, sbyte newValue)
 10899        {
 10900            return SetCell(rowIdentifier, columnIdentifier, ref m_AllSByteColumns, newValue);
 10901        }
 902
 903        /// <inheritdoc />
 904        public override ulong SetByte(int rowIdentifier, int columnIdentifier, byte newValue)
 10905        {
 10906            return SetCell(rowIdentifier, columnIdentifier, ref m_AllByteColumns, newValue);
 10907        }
 908
 909        /// <inheritdoc />
 910        public override ulong SetEnumInt(int rowIdentifier, int columnIdentifier, int newValue)
 0911        {
 0912            return SetCell(rowIdentifier, columnIdentifier, ref m_AllEnumIntColumns, newValue);
 0913        }
 914
 915        /// <inheritdoc />
 916        public override ulong SetShort(int rowIdentifier, int columnIdentifier, short newValue)
 10917        {
 10918            return SetCell(rowIdentifier, columnIdentifier, ref m_AllShortColumns, newValue);
 10919        }
 920
 921        /// <inheritdoc />
 922        public override ulong SetUShort(int rowIdentifier, int columnIdentifier, ushort newValue)
 10923        {
 10924            return SetCell(rowIdentifier, columnIdentifier, ref m_AllUShortColumns, newValue);
 10925        }
 926
 927        /// <inheritdoc />
 928        public override ulong SetInt(int rowIdentifier, int columnIdentifier, int newValue)
 10929        {
 10930            return SetCell(rowIdentifier, columnIdentifier, ref m_AllIntColumns, newValue);
 10931        }
 932
 933        /// <inheritdoc />
 934        public override ulong SetUInt(int rowIdentifier, int columnIdentifier, uint newValue)
 10935        {
 10936            return SetCell(rowIdentifier, columnIdentifier, ref m_AllUIntColumns, newValue);
 10937        }
 938
 939        /// <inheritdoc />
 940        public override ulong SetLong(int rowIdentifier, int columnIdentifier, long newValue)
 10941        {
 10942            return SetCell(rowIdentifier, columnIdentifier, ref m_AllLongColumns, newValue);
 10943        }
 944
 945        /// <inheritdoc />
 946        public override ulong SetULong(int rowIdentifier, int columnIdentifier, ulong newValue)
 10947        {
 10948            return SetCell(rowIdentifier, columnIdentifier, ref m_AllULongColumns, newValue);
 10949        }
 950
 951        /// <inheritdoc />
 952        public override ulong SetFloat(int rowIdentifier, int columnIdentifier, float newValue)
 10953        {
 10954            return SetCell(rowIdentifier, columnIdentifier, ref m_AllFloatColumns, newValue);
 10955        }
 956
 957        /// <inheritdoc />
 958        public override ulong SetDouble(int rowIdentifier, int columnIdentifier, double newValue)
 10959        {
 10960            return SetCell(rowIdentifier, columnIdentifier, ref m_AllDoubleColumns, newValue);
 10961        }
 962
 963        /// <inheritdoc />
 964        public override ulong SetVector2(int rowIdentifier, int columnIdentifier, Vector2 newStruct)
 10965        {
 10966            return SetCell(rowIdentifier, columnIdentifier, ref m_AllVector2Columns, newStruct);
 10967        }
 968
 969        /// <inheritdoc />
 970        public override ulong SetVector3(int rowIdentifier, int columnIdentifier, Vector3 newStruct)
 10971        {
 10972            return SetCell(rowIdentifier, columnIdentifier, ref m_AllVector3Columns, newStruct);
 10973        }
 974
 975        /// <inheritdoc />
 976        public override ulong SetVector4(int rowIdentifier, int columnIdentifier, Vector4 newStruct)
 10977        {
 10978            return SetCell(rowIdentifier, columnIdentifier, ref m_AllVector4Columns, newStruct);
 10979        }
 980
 981        /// <inheritdoc />
 982        public override ulong SetVector2Int(int rowIdentifier, int columnIdentifier, Vector2Int newStruct)
 10983        {
 10984            return SetCell(rowIdentifier, columnIdentifier, ref m_AllVector2IntColumns, newStruct);
 10985        }
 986
 987        /// <inheritdoc />
 988        public override ulong SetVector3Int(int rowIdentifier, int columnIdentifier, Vector3Int newStruct)
 10989        {
 10990            return SetCell(rowIdentifier, columnIdentifier, ref m_AllVector3IntColumns, newStruct);
 10991        }
 992
 993        /// <inheritdoc />
 994        public override ulong SetQuaternion(int rowIdentifier, int columnIdentifier, Quaternion newStruct)
 10995        {
 10996            return SetCell(rowIdentifier, columnIdentifier, ref m_AllQuaternionColumns, newStruct);
 10997        }
 998
 999        /// <inheritdoc />
 1000        public override ulong SetRect(int rowIdentifier, int columnIdentifier, Rect newStruct)
 101001        {
 101002            return SetCell(rowIdentifier, columnIdentifier, ref m_AllRectColumns, newStruct);
 101003        }
 1004
 1005        /// <inheritdoc />
 1006        public override ulong SetRectInt(int rowIdentifier, int columnIdentifier, RectInt newStruct)
 101007        {
 101008            return SetCell(rowIdentifier, columnIdentifier, ref m_AllRectIntColumns, newStruct);
 101009        }
 1010
 1011        /// <inheritdoc />
 1012        public override ulong SetColor(int rowIdentifier, int columnIdentifier, Color newStruct)
 101013        {
 101014            return SetCell(rowIdentifier, columnIdentifier, ref m_AllColorColumns, newStruct);
 101015        }
 1016
 1017        /// <inheritdoc />
 1018        public override ulong SetLayerMask(int rowIdentifier, int columnIdentifier, LayerMask newStruct)
 101019        {
 101020            return SetCell(rowIdentifier, columnIdentifier, ref m_AllLayerMaskColumns, newStruct);
 101021        }
 1022
 1023        /// <inheritdoc />
 1024        public override ulong SetBounds(int rowIdentifier, int columnIdentifier, Bounds newStruct)
 101025        {
 101026            return SetCell(rowIdentifier, columnIdentifier, ref m_AllBoundsColumns, newStruct);
 101027        }
 1028
 1029        /// <inheritdoc />
 1030        public override ulong SetBoundsInt(int rowIdentifier, int columnIdentifier, BoundsInt newStruct)
 101031        {
 101032            return SetCell(rowIdentifier, columnIdentifier, ref m_AllBoundsIntColumns, newStruct);
 101033        }
 1034
 1035        /// <inheritdoc />
 1036        public override ulong SetHash128(int rowIdentifier, int columnIdentifier, Hash128 newStruct)
 101037        {
 101038            return SetCell(rowIdentifier, columnIdentifier, ref m_AllHash128Columns, newStruct);
 101039        }
 1040
 1041        /// <inheritdoc />
 1042        public override ulong SetGradient(int rowIdentifier, int columnIdentifier, Gradient newObject)
 101043        {
 101044            return SetCell(rowIdentifier, columnIdentifier, ref m_AllGradientColumns, newObject);
 101045        }
 1046
 1047        /// <inheritdoc />
 1048        public override ulong SetAnimationCurve(int rowIdentifier, int columnIdentifier, AnimationCurve newObject)
 101049        {
 101050            return SetCell(rowIdentifier, columnIdentifier, ref m_AllAnimationCurveColumns, newObject);
 101051        }
 1052
 1053        /// <inheritdoc />
 1054        public override ulong SetObject(int rowIdentifier, int columnIdentifier, Object newObject)
 101055        {
 101056            return SetCell(rowIdentifier, columnIdentifier, ref m_AllObjectRefColumns, newObject);
 101057        }
 1058
 1059        /// <inheritdoc />
 1060        public override void SetTypeNameForColumn(int columnIdentifier, string assemblyQualifiedName)
 01061        {
 01062            ref ColumnEntry entry = ref m_ColumnIdentifierToDenseIndexMap[columnIdentifier];
 1063
 01064            if (entry.ColumnType == Serializable.SerializableTypes.Object)
 01065            {
 01066                m_AllObjectRefTypeNames[entry.ColumnDenseIndex] = assemblyQualifiedName;
 01067            }
 01068            else if (entry.ColumnType == Serializable.SerializableTypes.EnumInt)
 01069            {
 01070                m_AllEnumIntTypeNames[entry.ColumnDenseIndex] = assemblyQualifiedName;
 01071            }
 1072            else
 01073            {
 01074                throw new NotSupportedException(
 1075                    "Type name overloads are only supported for types inheriting from UnityEngine.Object or from System.
 1076            }
 01077        }
 1078
 1079        /// <inheritdoc />
 1080        public override string GetTypeNameForColumn(int columnIdentifier)
 01081        {
 01082            ref ColumnEntry entry = ref m_ColumnIdentifierToDenseIndexMap[columnIdentifier];
 01083            int denseIndex = entry.ColumnDenseIndex;
 1084
 01085            if (entry.ColumnType == Serializable.SerializableTypes.Object)
 01086            {
 01087                return m_AllObjectRefTypeNames[entry.ColumnDenseIndex];
 1088            }
 1089
 01090            if (entry.ColumnType == Serializable.SerializableTypes.EnumInt)
 01091            {
 01092                return m_AllEnumIntTypeNames[entry.ColumnDenseIndex];
 1093            }
 1094
 01095            throw new NotSupportedException(
 1096                "Type name overloads are only supported for types inheriting from UnityEngine.Object or from System.Enum
 01097        }
 1098
 1099        // Get
 1100        /// <inheritdoc />
 1101        public override string GetString(int rowIdentifier, int columnIdentifier)
 101102        {
 101103            return GetCell(rowIdentifier, columnIdentifier, ref m_AllStringColumns);
 101104        }
 1105
 1106        /// <inheritdoc />
 1107        public override bool GetBool(int rowIdentifier, int columnIdentifier)
 101108        {
 101109            return GetCell(rowIdentifier, columnIdentifier, ref m_AllBoolColumns);
 101110        }
 1111
 1112        /// <inheritdoc />
 1113        public override char GetChar(int rowIdentifier, int columnIdentifier)
 101114        {
 101115            return GetCell(rowIdentifier, columnIdentifier, ref m_AllCharColumns);
 101116        }
 1117
 1118        /// <inheritdoc />
 1119        public override int GetEnumInt(int rowIdentifier, int columnIdentifier)
 01120        {
 01121            return GetCell(rowIdentifier, columnIdentifier, ref m_AllEnumIntColumns);
 01122        }
 1123
 1124        /// <inheritdoc />
 1125        public override sbyte GetSByte(int rowIdentifier, int columnIdentifier)
 101126        {
 101127            return GetCell(rowIdentifier, columnIdentifier, ref m_AllSByteColumns);
 101128        }
 1129
 1130        /// <inheritdoc />
 1131        public override byte GetByte(int rowIdentifier, int columnIdentifier)
 101132        {
 101133            return GetCell(rowIdentifier, columnIdentifier, ref m_AllByteColumns);
 101134        }
 1135
 1136        /// <inheritdoc />
 1137        public override short GetShort(int rowIdentifier, int columnIdentifier)
 101138        {
 101139            return GetCell(rowIdentifier, columnIdentifier, ref m_AllShortColumns);
 101140        }
 1141
 1142        /// <inheritdoc />
 1143        public override ushort GetUShort(int rowIdentifier, int columnIdentifier)
 101144        {
 101145            return GetCell(rowIdentifier, columnIdentifier, ref m_AllUShortColumns);
 101146        }
 1147
 1148        /// <inheritdoc />
 1149        public override int GetInt(int rowIdentifier, int columnIdentifier)
 101150        {
 101151            return GetCell(rowIdentifier, columnIdentifier, ref m_AllIntColumns);
 101152        }
 1153
 1154        /// <inheritdoc />
 1155        public override uint GetUInt(int rowIdentifier, int columnIdentifier)
 101156        {
 101157            return GetCell(rowIdentifier, columnIdentifier, ref m_AllUIntColumns);
 101158        }
 1159
 1160        /// <inheritdoc />
 1161        public override long GetLong(int rowIdentifier, int columnIdentifier)
 101162        {
 101163            return GetCell(rowIdentifier, columnIdentifier, ref m_AllLongColumns);
 101164        }
 1165
 1166        /// <inheritdoc />
 1167        public override ulong GetULong(int rowIdentifier, int columnIdentifier)
 101168        {
 101169            return GetCell(rowIdentifier, columnIdentifier, ref m_AllULongColumns);
 101170        }
 1171
 1172        /// <inheritdoc />
 1173        public override float GetFloat(int rowIdentifier, int columnIdentifier)
 101174        {
 101175            return GetCell(rowIdentifier, columnIdentifier, ref m_AllFloatColumns);
 101176        }
 1177
 1178        /// <inheritdoc />
 1179        public override double GetDouble(int rowIdentifier, int columnIdentifier)
 101180        {
 101181            return GetCell(rowIdentifier, columnIdentifier, ref m_AllDoubleColumns);
 101182        }
 1183
 1184        /// <inheritdoc />
 1185        public override Vector2 GetVector2(int rowIdentifier, int columnIdentifier)
 101186        {
 101187            return GetCell(rowIdentifier, columnIdentifier, ref m_AllVector2Columns);
 101188        }
 1189
 1190        /// <inheritdoc />
 1191        public override Vector3 GetVector3(int rowIdentifier, int columnIdentifier)
 101192        {
 101193            return GetCell(rowIdentifier, columnIdentifier, ref m_AllVector3Columns);
 101194        }
 1195
 1196        /// <inheritdoc />
 1197        public override Vector4 GetVector4(int rowIdentifier, int columnIdentifier)
 101198        {
 101199            return GetCell(rowIdentifier, columnIdentifier, ref m_AllVector4Columns);
 101200        }
 1201
 1202        /// <inheritdoc />
 1203        public override Vector2Int GetVector2Int(int rowIdentifier, int columnIdentifier)
 101204        {
 101205            return GetCell(rowIdentifier, columnIdentifier, ref m_AllVector2IntColumns);
 101206        }
 1207
 1208        /// <inheritdoc />
 1209        public override Vector3Int GetVector3Int(int rowIdentifier, int columnIdentifier)
 101210        {
 101211            return GetCell(rowIdentifier, columnIdentifier, ref m_AllVector3IntColumns);
 101212        }
 1213
 1214        /// <inheritdoc />
 1215        public override Quaternion GetQuaternion(int rowIdentifier, int columnIdentifier)
 101216        {
 101217            return GetCell(rowIdentifier, columnIdentifier, ref m_AllQuaternionColumns);
 101218        }
 1219
 1220        /// <inheritdoc />
 1221        public override Rect GetRect(int rowIdentifier, int columnIdentifier)
 101222        {
 101223            return GetCell(rowIdentifier, columnIdentifier, ref m_AllRectColumns);
 101224        }
 1225
 1226        /// <inheritdoc />
 1227        public override RectInt GetRectInt(int rowIdentifier, int columnIdentifier)
 101228        {
 101229            return GetCell(rowIdentifier, columnIdentifier, ref m_AllRectIntColumns);
 101230        }
 1231
 1232        /// <inheritdoc />
 1233        public override Color GetColor(int rowIdentifier, int columnIdentifier)
 101234        {
 101235            return GetCell(rowIdentifier, columnIdentifier, ref m_AllColorColumns);
 101236        }
 1237
 1238        /// <inheritdoc />
 1239        public override LayerMask GetLayerMask(int rowIdentifier, int columnIdentifier)
 101240        {
 101241            return GetCell(rowIdentifier, columnIdentifier, ref m_AllLayerMaskColumns);
 101242        }
 1243
 1244        /// <inheritdoc />
 1245        public override Bounds GetBounds(int rowIdentifier, int columnIdentifier)
 101246        {
 101247            return GetCell(rowIdentifier, columnIdentifier, ref m_AllBoundsColumns);
 101248        }
 1249
 1250        /// <inheritdoc />
 1251        public override BoundsInt GetBoundsInt(int rowIdentifier, int columnIdentifier)
 101252        {
 101253            return GetCell(rowIdentifier, columnIdentifier, ref m_AllBoundsIntColumns);
 101254        }
 1255
 1256        /// <inheritdoc />
 1257        public override Hash128 GetHash128(int rowIdentifier, int columnIdentifier)
 101258        {
 101259            return GetCell(rowIdentifier, columnIdentifier, ref m_AllHash128Columns);
 101260        }
 1261
 1262        /// <inheritdoc />
 1263        public override Gradient GetGradient(int rowIdentifier, int columnIdentifier)
 101264        {
 101265            return GetCell(rowIdentifier, columnIdentifier, ref m_AllGradientColumns);
 101266        }
 1267
 1268        /// <inheritdoc />
 1269        public override AnimationCurve GetAnimationCurve(int rowIdentifier, int columnIdentifier)
 101270        {
 101271            return GetCell(rowIdentifier, columnIdentifier, ref m_AllAnimationCurveColumns);
 101272        }
 1273
 1274        /// <inheritdoc />
 1275        public override Object GetObject(int rowIdentifier, int columnIdentifier)
 101276        {
 101277            return GetCell(rowIdentifier, columnIdentifier, ref m_AllObjectRefColumns);
 101278        }
 1279
 1280        // Get ref
 1281
 1282        public ref string GetStringRef(int row, int column)
 101283        {
 101284            return ref GetCellRef(row, column, ref m_AllStringColumns);
 101285        }
 1286
 1287        public ref bool GetBoolRef(int row, int column)
 101288        {
 101289            return ref GetCellRef(row, column, ref m_AllBoolColumns);
 101290        }
 1291
 1292        public ref char GetCharRef(int row, int column)
 101293        {
 101294            return ref GetCellRef(row, column, ref m_AllCharColumns);
 101295        }
 1296
 1297        public ref sbyte GetSbyteRef(int row, int column)
 101298        {
 101299            return ref GetCellRef(row, column, ref m_AllSByteColumns);
 101300        }
 1301
 1302        public ref byte GetByteRef(int row, int columnID)
 101303        {
 101304            return ref GetCellRef(row, columnID, ref m_AllByteColumns);
 101305        }
 1306
 1307        public ref short GetShortRef(int row, int column)
 101308        {
 101309            return ref GetCellRef(row, column, ref m_AllShortColumns);
 101310        }
 1311
 1312        public ref ushort GetUshortRef(int row, int column)
 101313        {
 101314            return ref GetCellRef(row, column, ref m_AllUShortColumns);
 101315        }
 1316
 1317        public ref int GetIntRef(int row, int column)
 101318        {
 101319            return ref GetCellRef(row, column, ref m_AllIntColumns);
 101320        }
 1321
 1322        public ref uint GetUintRef(int row, int column)
 101323        {
 101324            return ref GetCellRef(row, column, ref m_AllUIntColumns);
 101325        }
 1326
 1327        public ref long GetLongRef(int row, int column)
 101328        {
 101329            return ref GetCellRef(row, column, ref m_AllLongColumns);
 101330        }
 1331
 1332        public ref ulong GetUlongRef(int row, int column)
 101333        {
 101334            return ref GetCellRef(row, column, ref m_AllULongColumns);
 101335        }
 1336
 1337        public ref float GetFloatRef(int row, int column)
 101338        {
 101339            return ref GetCellRef(row, column, ref m_AllFloatColumns);
 101340        }
 1341
 1342        public ref double GetDoubleRef(int row, int column)
 101343        {
 101344            return ref GetCellRef(row, column, ref m_AllDoubleColumns);
 101345        }
 1346
 1347        public ref Vector2 GetVector2Ref(int row, int column)
 101348        {
 101349            return ref GetCellRef(row, column, ref m_AllVector2Columns);
 101350        }
 1351
 1352        public ref Vector3 GetVector3Ref(int row, int column)
 101353        {
 101354            return ref GetCellRef(row, column, ref m_AllVector3Columns);
 101355        }
 1356
 1357        public ref Vector4 GetVector4Ref(int row, int column)
 101358        {
 101359            return ref GetCellRef(row, column, ref m_AllVector4Columns);
 101360        }
 1361
 1362        public ref Vector2Int GetVector2IntRef(int row, int column)
 101363        {
 101364            return ref GetCellRef(row, column, ref m_AllVector2IntColumns);
 101365        }
 1366
 1367        public ref Vector3Int GetVector3IntRef(int row, int column)
 101368        {
 101369            return ref GetCellRef(row, column, ref m_AllVector3IntColumns);
 101370        }
 1371
 1372        public ref Quaternion GetQuaternionRef(int row, int column)
 101373        {
 101374            return ref GetCellRef(row, column, ref m_AllQuaternionColumns);
 101375        }
 1376
 1377        public ref Rect GetRectRef(int row, int column)
 101378        {
 101379            return ref GetCellRef(row, column, ref m_AllRectColumns);
 101380        }
 1381
 1382        public ref RectInt GetRectIntRef(int row, int column)
 101383        {
 101384            return ref GetCellRef(row, column, ref m_AllRectIntColumns);
 101385        }
 1386
 1387        public ref Color GetColorRef(int row, int column)
 101388        {
 101389            return ref GetCellRef(row, column, ref m_AllColorColumns);
 101390        }
 1391
 1392        public ref LayerMask GetLayerMaskRef(int row, int column)
 101393        {
 101394            return ref GetCellRef(row, column, ref m_AllLayerMaskColumns);
 101395        }
 1396
 1397        public ref Bounds GetBoundsRef(int row, int column)
 101398        {
 101399            return ref GetCellRef(row, column, ref m_AllBoundsColumns);
 101400        }
 1401
 1402        public ref BoundsInt GetBoundsIntRef(int row, int column)
 101403        {
 101404            return ref GetCellRef(row, column, ref m_AllBoundsIntColumns);
 101405        }
 1406
 1407        public ref Hash128 GetHash128Ref(int row, int column)
 101408        {
 101409            return ref GetCellRef(row, column, ref m_AllHash128Columns);
 101410        }
 1411
 1412        public ref Gradient GetGradientRef(int row, int column)
 101413        {
 101414            return ref GetCellRef(row, column, ref m_AllGradientColumns);
 101415        }
 1416
 1417        public ref AnimationCurve GetAnimationCurveRef(int row, int column)
 101418        {
 101419            return ref GetCellRef(row, column, ref m_AllAnimationCurveColumns);
 101420        }
 1421
 1422        public ref Object GetObjectRef(int row, int column)
 101423        {
 101424            return ref GetCellRef(row, column, ref m_AllObjectRefColumns);
 101425        }
 1426
 1427        // Get Column
 1428
 1429        public string[] GetStringColumn(int column)
 01430        {
 01431            return GetColumn(column, ref m_AllStringColumns);
 01432        }
 1433
 1434        public bool[] GetBoolColumn(int column)
 01435        {
 01436            return GetColumn(column, ref m_AllBoolColumns);
 01437        }
 1438
 1439        public char[] GetCharColumn(int column)
 01440        {
 01441            return GetColumn(column, ref m_AllCharColumns);
 01442        }
 1443
 1444        public sbyte[] GetSbyteColumn(int column)
 01445        {
 01446            return GetColumn(column, ref m_AllSByteColumns);
 01447        }
 1448
 1449        public byte[] GetByteColumn(int column)
 01450        {
 01451            return GetColumn(column, ref m_AllByteColumns);
 01452        }
 1453
 1454        public short[] GetShortColumn(int column)
 01455        {
 01456            return GetColumn(column, ref m_AllShortColumns);
 01457        }
 1458
 1459        public ushort[] GetUshortColumn(int column)
 01460        {
 01461            return GetColumn(column, ref m_AllUShortColumns);
 01462        }
 1463
 1464        public int[] GetIntColumn(int column)
 01465        {
 01466            return GetColumn(column, ref m_AllIntColumns);
 01467        }
 1468
 1469        public uint[] GetUintColumn(int column)
 01470        {
 01471            return GetColumn(column, ref m_AllUIntColumns);
 01472        }
 1473
 1474        public long[] GetLongColumn(int column)
 01475        {
 01476            return GetColumn(column, ref m_AllLongColumns);
 01477        }
 1478
 1479        public ulong[] GetUlongColumn(int column)
 01480        {
 01481            return GetColumn(column, ref m_AllULongColumns);
 01482        }
 1483
 1484        public float[] GetFloatColumn(int column)
 01485        {
 01486            return GetColumn(column, ref m_AllFloatColumns);
 01487        }
 1488
 1489        public double[] GetDoubleColumn(int column)
 01490        {
 01491            return GetColumn(column, ref m_AllDoubleColumns);
 01492        }
 1493
 1494        public Vector2[] GetVector2Column(int column)
 01495        {
 01496            return GetColumn(column, ref m_AllVector2Columns);
 01497        }
 1498
 1499        public Vector3[] GetVector3Column(int column)
 01500        {
 01501            return GetColumn(column, ref m_AllVector3Columns);
 01502        }
 1503
 1504        public Vector4[] GetVector4Column(int column)
 01505        {
 01506            return GetColumn(column, ref m_AllVector4Columns);
 01507        }
 1508
 1509        public Vector2Int[] GetVector2IntColumn(int column)
 01510        {
 01511            return GetColumn(column, ref m_AllVector2IntColumns);
 01512        }
 1513
 1514        public Vector3Int[] GetVector3IntColumn(int column)
 01515        {
 01516            return GetColumn(column, ref m_AllVector3IntColumns);
 01517        }
 1518
 1519        public Quaternion[] GetQuaternionColumn(int column)
 01520        {
 01521            return GetColumn(column, ref m_AllQuaternionColumns);
 01522        }
 1523
 1524        public Rect[] GetRectColumn(int column)
 01525        {
 01526            return GetColumn(column, ref m_AllRectColumns);
 01527        }
 1528
 1529        public RectInt[] GetRectIntColumn(int column)
 01530        {
 01531            return GetColumn(column, ref m_AllRectIntColumns);
 01532        }
 1533
 1534        public Color[] GetColorColumn(int column)
 01535        {
 01536            return GetColumn(column, ref m_AllColorColumns);
 01537        }
 1538
 1539        public LayerMask[] GetLayerMaskColumn(int column)
 01540        {
 01541            return GetColumn(column, ref m_AllLayerMaskColumns);
 01542        }
 1543
 1544        public Bounds[] GetBoundsColumn(int column)
 01545        {
 01546            return GetColumn(column, ref m_AllBoundsColumns);
 01547        }
 1548
 1549        public BoundsInt[] GetBoundsIntColumn(int column)
 01550        {
 01551            return GetColumn(column, ref m_AllBoundsIntColumns);
 01552        }
 1553
 1554        public Hash128[] GetHash128Column(int column)
 01555        {
 01556            return GetColumn(column, ref m_AllHash128Columns);
 01557        }
 1558
 1559        public Gradient[] GetGradientColumn(int column)
 01560        {
 01561            return GetColumn(column, ref m_AllGradientColumns);
 01562        }
 1563
 1564        public AnimationCurve[] GetAnimationCurveColumn(int column)
 01565        {
 01566            return GetColumn(column, ref m_AllAnimationCurveColumns);
 01567        }
 1568
 1569        public Object[] GetObjectColumn(int column)
 01570        {
 01571            return GetColumn(column, ref m_AllObjectRefColumns);
 01572        }
 1573
 1574        // SetOrder
 1575
 1576        /// <inheritdoc />
 1577        public override int GetColumnOrder(int columnIdentifier)
 01578        {
 01579            return m_ColumnIdentifierToSortOrderMap[columnIdentifier];
 01580        }
 1581
 1582        /// <inheritdoc />
 1583        public override void SetColumnOrder(int columnIdentifier, int newSortOrder)
 01584        {
 01585            AssertColumnIdentifierValid(columnIdentifier);
 01586            AssertColumnSortOrderValid(newSortOrder);
 01587            int oldSortOrder = m_ColumnIdentifierToSortOrderMap[columnIdentifier];
 01588            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01589            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01590            {
 01591                int columnIDAt = m_SortedOrderToColumnIdentifierMap[i + iterDirection];
 01592                m_ColumnIdentifierToSortOrderMap[columnIDAt] = i;
 01593                m_SortedOrderToColumnIdentifierMap[i] = m_SortedOrderToColumnIdentifierMap[i + iterDirection];
 01594            }
 1595
 01596            m_SortedOrderToColumnIdentifierMap[newSortOrder] = columnIdentifier;
 01597            m_ColumnIdentifierToSortOrderMap[columnIdentifier] = newSortOrder;
 01598        }
 1599
 1600        /// <inheritdoc />
 1601        public override void SetAllColumnOrders(int[] orderedColumnIdentifiers)
 01602        {
 01603            AssertSortedColumnsArgValid(orderedColumnIdentifiers);
 01604            for (int i = 0; i < m_SortedOrderToColumnIdentifierMap.Length; i++)
 01605            {
 01606                int columnID = orderedColumnIdentifiers[i];
 01607                m_SortedOrderToColumnIdentifierMap[i] = columnID;
 01608                m_ColumnIdentifierToSortOrderMap[columnID] = i;
 01609            }
 01610        }
 1611
 1612        /// <inheritdoc />
 1613        public override int GetRowOrder(int rowIdentifier)
 01614        {
 01615            return m_RowIdentifierToDenseIndexMap[rowIdentifier];
 01616        }
 1617
 1618        /// <inheritdoc />
 1619        public override void SetRowOrder(int rowIdentifier, int newSortOrder)
 01620        {
 01621            AssertRowIdentifierValid(rowIdentifier);
 01622            AssertRowSortOrderValid(newSortOrder);
 1623
 01624            int oldSortOrder = m_RowIdentifierToDenseIndexMap[rowIdentifier];
 01625            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01626            string rowName = m_RowNames[oldSortOrder];
 1627
 01628            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01629            {
 01630                int rowIDAt = m_RowDenseIndexToIDMap[i + iterDirection];
 01631                m_RowIdentifierToDenseIndexMap[rowIDAt] = i;
 01632                m_RowDenseIndexToIDMap[i] = rowIDAt;
 01633                m_RowNames[i] = m_RowNames[i + iterDirection];
 01634            }
 1635
 01636            m_RowDenseIndexToIDMap[newSortOrder] = rowIdentifier;
 01637            m_RowIdentifierToDenseIndexMap[rowIdentifier] = newSortOrder;
 01638            m_RowNames[newSortOrder] = rowName;
 1639
 01640            SetRowOrderForColumns(m_AllStringColumns, oldSortOrder, newSortOrder);
 01641            SetRowOrderForColumns(m_AllBoolColumns, oldSortOrder, newSortOrder);
 01642            SetRowOrderForColumns(m_AllCharColumns, oldSortOrder, newSortOrder);
 01643            SetRowOrderForColumns(m_AllSByteColumns, oldSortOrder, newSortOrder);
 01644            SetRowOrderForColumns(m_AllByteColumns, oldSortOrder, newSortOrder);
 01645            SetRowOrderForColumns(m_AllShortColumns, oldSortOrder, newSortOrder);
 01646            SetRowOrderForColumns(m_AllUShortColumns, oldSortOrder, newSortOrder);
 01647            SetRowOrderForColumns(m_AllIntColumns, oldSortOrder, newSortOrder);
 01648            SetRowOrderForColumns(m_AllUIntColumns, oldSortOrder, newSortOrder);
 01649            SetRowOrderForColumns(m_AllLongColumns, oldSortOrder, newSortOrder);
 01650            SetRowOrderForColumns(m_AllULongColumns, oldSortOrder, newSortOrder);
 01651            SetRowOrderForColumns(m_AllFloatColumns, oldSortOrder, newSortOrder);
 01652            SetRowOrderForColumns(m_AllDoubleColumns, oldSortOrder, newSortOrder);
 01653            SetRowOrderForColumns(m_AllVector2Columns, oldSortOrder, newSortOrder);
 01654            SetRowOrderForColumns(m_AllVector3Columns, oldSortOrder, newSortOrder);
 01655            SetRowOrderForColumns(m_AllVector4Columns, oldSortOrder, newSortOrder);
 01656            SetRowOrderForColumns(m_AllVector2IntColumns, oldSortOrder, newSortOrder);
 01657            SetRowOrderForColumns(m_AllVector3IntColumns, oldSortOrder, newSortOrder);
 01658            SetRowOrderForColumns(m_AllQuaternionColumns, oldSortOrder, newSortOrder);
 01659            SetRowOrderForColumns(m_AllRectColumns, oldSortOrder, newSortOrder);
 01660            SetRowOrderForColumns(m_AllRectIntColumns, oldSortOrder, newSortOrder);
 01661            SetRowOrderForColumns(m_AllColorColumns, oldSortOrder, newSortOrder);
 01662            SetRowOrderForColumns(m_AllLayerMaskColumns, oldSortOrder, newSortOrder);
 01663            SetRowOrderForColumns(m_AllBoundsColumns, oldSortOrder, newSortOrder);
 01664            SetRowOrderForColumns(m_AllBoundsIntColumns, oldSortOrder, newSortOrder);
 01665            SetRowOrderForColumns(m_AllHash128Columns, oldSortOrder, newSortOrder);
 01666            SetRowOrderForColumns(m_AllGradientColumns, oldSortOrder, newSortOrder);
 01667            SetRowOrderForColumns(m_AllAnimationCurveColumns, oldSortOrder, newSortOrder);
 01668            SetRowOrderForColumns(m_AllObjectRefColumns, oldSortOrder, newSortOrder);
 01669            SetRowOrderForColumns(m_AllEnumIntColumns, oldSortOrder, newSortOrder);
 01670        }
 1671
 1672        /// <inheritdoc />
 1673        public override void SetAllRowOrders(int[] orderedRowIdentifiers)
 01674        {
 01675            AssertSortRowsArgValid(orderedRowIdentifiers);
 1676
 01677            ReSortRows(m_AllStringColumns, orderedRowIdentifiers);
 01678            ReSortRows(m_AllBoolColumns, orderedRowIdentifiers);
 01679            ReSortRows(m_AllCharColumns, orderedRowIdentifiers);
 01680            ReSortRows(m_AllSByteColumns, orderedRowIdentifiers);
 01681            ReSortRows(m_AllByteColumns, orderedRowIdentifiers);
 01682            ReSortRows(m_AllShortColumns, orderedRowIdentifiers);
 01683            ReSortRows(m_AllUShortColumns, orderedRowIdentifiers);
 01684            ReSortRows(m_AllIntColumns, orderedRowIdentifiers);
 01685            ReSortRows(m_AllUIntColumns, orderedRowIdentifiers);
 01686            ReSortRows(m_AllLongColumns, orderedRowIdentifiers);
 01687            ReSortRows(m_AllULongColumns, orderedRowIdentifiers);
 01688            ReSortRows(m_AllFloatColumns, orderedRowIdentifiers);
 01689            ReSortRows(m_AllDoubleColumns, orderedRowIdentifiers);
 01690            ReSortRows(m_AllVector2Columns, orderedRowIdentifiers);
 01691            ReSortRows(m_AllVector3Columns, orderedRowIdentifiers);
 01692            ReSortRows(m_AllVector4Columns, orderedRowIdentifiers);
 01693            ReSortRows(m_AllVector2IntColumns, orderedRowIdentifiers);
 01694            ReSortRows(m_AllVector3IntColumns, orderedRowIdentifiers);
 01695            ReSortRows(m_AllQuaternionColumns, orderedRowIdentifiers);
 01696            ReSortRows(m_AllRectColumns, orderedRowIdentifiers);
 01697            ReSortRows(m_AllRectIntColumns, orderedRowIdentifiers);
 01698            ReSortRows(m_AllColorColumns, orderedRowIdentifiers);
 01699            ReSortRows(m_AllLayerMaskColumns, orderedRowIdentifiers);
 01700            ReSortRows(m_AllBoundsColumns, orderedRowIdentifiers);
 01701            ReSortRows(m_AllBoundsIntColumns, orderedRowIdentifiers);
 01702            ReSortRows(m_AllHash128Columns, orderedRowIdentifiers);
 01703            ReSortRows(m_AllGradientColumns, orderedRowIdentifiers);
 01704            ReSortRows(m_AllAnimationCurveColumns, orderedRowIdentifiers);
 01705            ReSortRows(m_AllObjectRefColumns, orderedRowIdentifiers);
 01706            ReSortRows(m_AllEnumIntColumns, orderedRowIdentifiers);
 1707
 01708            int namesCount = m_RowNames?.Length ?? 0;
 01709            string[] newNames = new string[namesCount];
 01710            for (int i = 0; i < namesCount; i++)
 01711            {
 01712                int rowID = orderedRowIdentifiers[i];
 01713                int oldRowIndex = m_RowIdentifierToDenseIndexMap[rowID];
 1714
 01715                newNames[i] = m_RowNames[oldRowIndex];
 01716            }
 1717
 01718            m_RowNames = newNames;
 1719
 01720            for (int i = 0; i < orderedRowIdentifiers.Length; i++)
 01721            {
 01722                int rowID = orderedRowIdentifiers[i];
 01723                m_RowDenseIndexToIDMap[i] = rowID;
 01724                m_RowIdentifierToDenseIndexMap[rowID] = i;
 01725            }
 01726        }
 1727
 1728        internal void ReSortRows<T>(ArrayHolder<T>[] columns, int[] sortedRowIDs)
 01729        {
 01730            int columnCount = columns?.Length ?? 0;
 01731            for (int i = 0; i < columnCount; i++)
 01732            {
 01733                T[] column = columns[i].TArray;
 01734                T[] newColumn = new T[column.Length];
 01735                for (int j = 0; j < sortedRowIDs.Length; j++)
 01736                {
 01737                    int rowID = sortedRowIDs[j];
 01738                    int oldRowIndex = m_RowIdentifierToDenseIndexMap[rowID];
 1739
 01740                    newColumn[j] = column[oldRowIndex];
 01741                }
 1742
 01743                columns[i].TArray = newColumn;
 01744            }
 01745        }
 1746
 1747        // Internal
 1748
 1749        internal void AddTypeNameEntry(ref string[] typeNames, string defaultString)
 71750        {
 71751            int nameArrayLength = typeNames?.Length ?? 0;
 71752            Array.Resize(ref typeNames, nameArrayLength + 1);
 71753            typeNames[nameArrayLength] = defaultString;
 71754        }
 1755
 1756        internal void RemoveTypeNameEntry(int columnDenseIndex, ref string[] typeNames)
 01757        {
 01758            int nameArrayLength = typeNames?.Length ?? 0;
 01759            typeNames[columnDenseIndex] = typeNames[nameArrayLength - 1];
 01760            Array.Resize(ref typeNames, nameArrayLength - 1);
 01761        }
 1762
 1763        internal int AddColumnInternal<T>(string columnName, ref ArrayHolder<T>[] allColumnsOfType,
 1764            Serializable.SerializableTypes typeIndex, int insertAtColumnIdentifier)
 1141765        {
 1141766            if (insertAtColumnIdentifier >= 0)
 01767            {
 01768                AssertColumnIdentifierValid(insertAtColumnIdentifier);
 01769            }
 1770
 1141771            int columnCount = allColumnsOfType?.Length ?? 0;
 1141772            Array.Resize(ref allColumnsOfType, columnCount + 1);
 1141773            allColumnsOfType[columnCount].TArray = new T[m_RowCount];
 1774
 1141775            int columnID = m_ColumnEntriesFreeListHead;
 1141776            string[] columnNamesForType = m_AllColumnNames[(int)typeIndex].TArray;
 1141777            int columnNamesCount = columnNamesForType?.Length ?? 0;
 1141778            Array.Resize(ref columnNamesForType, columnNamesCount + 1);
 1141779            columnNamesForType[columnNamesCount] = columnName == null ? columnID.ToString() : columnName;
 1141780            m_AllColumnNames[(int)typeIndex].TArray = columnNamesForType;
 1781
 1782
 1141783            int columnIDToDenseIndexMapLength = m_ColumnIdentifierToDenseIndexMap?.Length ?? 0;
 1141784            if (columnID >= columnIDToDenseIndexMapLength)
 311785            {
 311786                int newSize = columnIDToDenseIndexMapLength * 2;
 311787                newSize = newSize == 0 ? 1 : newSize;
 311788                Array.Resize(ref m_ColumnIdentifierToDenseIndexMap, newSize);
 3121789                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 1251790                {
 1251791                    ref ColumnEntry entry = ref m_ColumnIdentifierToDenseIndexMap[i];
 1251792                    entry.ColumnDenseIndex = i + 1;
 1251793                    entry.ColumnType = Serializable.SerializableTypes.Invalid;
 1251794                }
 1795
 311796                Array.Resize(ref m_ColumnIdentifierToSortOrderMap, newSize);
 3121797                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 1251798                {
 1251799                    m_ColumnIdentifierToSortOrderMap[i] = -1;
 1251800                }
 311801            }
 1802
 1141803            m_ColumnEntriesFreeListHead = m_ColumnIdentifierToDenseIndexMap[columnID].ColumnDenseIndex;
 1804
 1141805            ref int[] denseIndexToIDMap = ref m_ColumnDenseIndexToIDMap[(int)typeIndex].TArray;
 1141806            int denseIndexToIDMapLength = denseIndexToIDMap?.Length ?? 0;
 1141807            Array.Resize(ref denseIndexToIDMap, denseIndexToIDMapLength + 1);
 1141808            denseIndexToIDMap[denseIndexToIDMapLength] = columnID;
 1809
 1141810            ref ColumnEntry newEntry = ref m_ColumnIdentifierToDenseIndexMap[columnID];
 1141811            newEntry.ColumnDenseIndex = denseIndexToIDMapLength;
 1141812            newEntry.ColumnType = typeIndex;
 1813
 1141814            int insertAtSortedIndex =
 1815                insertAtColumnIdentifier < 0
 1816                    ? m_CombinedColumnCount
 1817                    : m_ColumnIdentifierToSortOrderMap[insertAtColumnIdentifier];
 1141818            Array.Resize(ref m_SortedOrderToColumnIdentifierMap, m_CombinedColumnCount + 1);
 2281819            for (int i = m_CombinedColumnCount; i > insertAtSortedIndex; i--)
 01820            {
 01821                int currentColumnID = m_SortedOrderToColumnIdentifierMap[i - 1];
 01822                m_SortedOrderToColumnIdentifierMap[i] = currentColumnID;
 01823                m_ColumnIdentifierToSortOrderMap[currentColumnID] = i;
 01824            }
 1825
 1141826            if (typeIndex == Serializable.SerializableTypes.Object)
 41827            {
 41828                AddTypeNameEntry(ref m_AllObjectRefTypeNames, Reflection.UnityObjectName);
 41829            }
 1830
 1141831            if (typeIndex == Serializable.SerializableTypes.EnumInt)
 31832            {
 31833                AddTypeNameEntry(ref m_AllEnumIntTypeNames, Reflection.SerializedTypesName);
 31834            }
 1835
 1141836            m_ColumnIdentifierToSortOrderMap[columnID] = insertAtSortedIndex;
 1141837            m_SortedOrderToColumnIdentifierMap[insertAtSortedIndex] = columnID;
 1838
 1141839            ++m_CombinedColumnCount;
 1141840            m_DataVersion++;
 1841
 1141842            return columnID;
 1141843        }
 1844
 1845        internal void RemoveColumnInternal<T>(ref ArrayHolder<T>[] allColumnsOfType,
 1846            Serializable.SerializableTypes typeIndex, int columnID)
 41847        {
 41848            AssertColumnIdentifierValid(columnID);
 41849            int columnLocation = m_ColumnIdentifierToDenseIndexMap[columnID].ColumnDenseIndex;
 1850
 41851            int lastIndex = allColumnsOfType.Length - 1;
 41852            allColumnsOfType[columnLocation] = allColumnsOfType[lastIndex];
 41853            Array.Resize(ref allColumnsOfType, lastIndex);
 1854
 41855            ref string[] columnNamesOfType = ref m_AllColumnNames[(int)typeIndex].TArray;
 41856            columnNamesOfType[columnLocation] = columnNamesOfType[lastIndex];
 41857            Array.Resize(ref columnNamesOfType, lastIndex);
 1858
 41859            int columnOrder = m_ColumnIdentifierToSortOrderMap[columnID];
 1860
 41861            ref int[] denseIndicesOfType = ref m_ColumnDenseIndexToIDMap[(int)typeIndex].TArray;
 41862            int sparseIndexToSwap = denseIndicesOfType[lastIndex];
 1863
 41864            m_ColumnIdentifierToDenseIndexMap[sparseIndexToSwap].ColumnDenseIndex = columnLocation;
 41865            ref ColumnEntry sparseIndexToFree = ref m_ColumnIdentifierToDenseIndexMap[columnID];
 41866            sparseIndexToFree.ColumnType = Serializable.SerializableTypes.Invalid;
 41867            sparseIndexToFree.ColumnDenseIndex = m_ColumnEntriesFreeListHead;
 1868
 41869            m_ColumnEntriesFreeListHead = columnID;
 1870
 41871            denseIndicesOfType[columnLocation] = sparseIndexToSwap;
 41872            Array.Resize(ref denseIndicesOfType, lastIndex);
 1873
 41874            if (typeIndex == Serializable.SerializableTypes.Object)
 01875            {
 01876                RemoveTypeNameEntry(columnLocation, ref m_AllObjectRefTypeNames);
 01877            }
 1878
 41879            if (typeIndex == Serializable.SerializableTypes.EnumInt)
 01880            {
 01881                RemoveTypeNameEntry(columnLocation, ref m_AllEnumIntTypeNames);
 01882            }
 1883
 161884            for (int i = columnOrder + 1; i < m_CombinedColumnCount; i++)
 41885            {
 41886                int currentColumnID = m_SortedOrderToColumnIdentifierMap[i];
 41887                m_SortedOrderToColumnIdentifierMap[i - 1] = currentColumnID;
 41888                m_ColumnIdentifierToSortOrderMap[currentColumnID] = i - 1;
 41889            }
 1890
 41891            m_ColumnIdentifierToSortOrderMap[columnID] = -1;
 1892
 41893            Array.Resize(ref m_SortedOrderToColumnIdentifierMap, m_CombinedColumnCount - 1);
 1894
 41895            --m_CombinedColumnCount;
 41896            m_DataVersion++;
 41897        }
 1898
 1899        internal void InsertRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int insertAt,
 1900            int numberOfNewRows)
 16801901        {
 16801902            int columnCount = allColumnsOfType?.Length ?? 0;
 49481903            for (int i = 0; i < columnCount; i++)
 7941904            {
 7941905                ref T[] rows = ref allColumnsOfType[i].TArray;
 7941906                int newRowCount = m_RowCount + numberOfNewRows;
 7941907                Array.Resize(ref rows, newRowCount);
 15881908                for (int j = newRowCount - 1; j > insertAt + numberOfNewRows - 1; j--)
 01909                {
 01910                    rows[j] = rows[j - numberOfNewRows];
 01911                }
 1912
 31761913                for (int j = 0; j < numberOfNewRows; j++)
 7941914                {
 7941915                    rows[insertAt + j] = default;
 7941916                }
 7941917            }
 16801918        }
 1919
 1920        internal void DeleteRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int removeAt,
 1921            int numberOfRowsToDelete)
 01922        {
 01923            int columnCount = allColumnsOfType?.Length ?? 0;
 1924
 01925            for (int i = 0; i < columnCount; i++)
 01926            {
 01927                ref T[] rows = ref allColumnsOfType[i].TArray;
 01928                int newRowCount = m_RowCount - numberOfRowsToDelete;
 1929
 01930                for (int j = removeAt + numberOfRowsToDelete; j < m_RowCount; j++)
 01931                {
 01932                    rows[j - numberOfRowsToDelete] = rows[j];
 01933                }
 1934
 01935                Array.Resize(ref rows, newRowCount);
 01936            }
 01937        }
 1938
 1939        internal ref T GetCellRef<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 2901940        {
 2901941            AssertColumnIdentifierValid(columnID);
 2901942            AssertRowIdentifierValid(rowID);
 2901943            int column = m_ColumnIdentifierToDenseIndexMap[columnID].ColumnDenseIndex;
 2901944            int row = m_RowIdentifierToDenseIndexMap[rowID];
 2901945            return ref allColumnsOfType[column][row];
 2901946        }
 1947
 1948        internal T GetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 2901949        {
 2901950            AssertColumnIdentifierValid(columnID);
 2901951            AssertRowIdentifierValid(rowID);
 2901952            int column = m_ColumnIdentifierToDenseIndexMap[columnID].ColumnDenseIndex;
 2901953            int row = m_RowIdentifierToDenseIndexMap[rowID];
 2901954            return allColumnsOfType[column][row];
 2901955        }
 1956
 1957        internal ulong SetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType, T value)
 2901958        {
 2901959            AssertColumnIdentifierValid(columnID);
 2901960            AssertRowIdentifierValid(rowID);
 2901961            int column = m_ColumnIdentifierToDenseIndexMap[columnID].ColumnDenseIndex;
 2901962            int row = m_RowIdentifierToDenseIndexMap[rowID];
 2901963            allColumnsOfType[column][row] = value;
 2901964            m_DataVersion++;
 2901965            return m_DataVersion;
 2901966        }
 1967
 1968        internal T[] GetColumn<T>(int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01969        {
 01970            AssertColumnIdentifierValid(columnID);
 01971            int column = m_ColumnIdentifierToDenseIndexMap[columnID].ColumnDenseIndex;
 01972            return allColumnsOfType[column].TArray;
 01973        }
 1974
 1975        internal void SetRowOrderForColumns<T>(ArrayHolder<T>[] columns, int oldSortOrder, int newSortOrder)
 01976        {
 01977            int columnCount = columns?.Length ?? 0;
 01978            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01979            for (int i = 0; i < columnCount; i++)
 01980            {
 01981                T[] column = columns[i].TArray;
 1982
 01983                T value = column[oldSortOrder];
 1984
 01985                for (int j = oldSortOrder; j != newSortOrder; j += iterDirection)
 01986                {
 01987                    column[j] = column[j + iterDirection];
 01988                }
 1989
 01990                column[newSortOrder] = value;
 01991            }
 01992        }
 1993
 1994        internal void AssertSortedColumnsArgValid(int[] sortedColumnIDs)
 01995        {
 01996            if (sortedColumnIDs == null)
 01997            {
 01998                throw new ArgumentException("sortedColumnIDs array cannot be null.");
 1999            }
 2000
 02001            if (sortedColumnIDs.Length != m_SortedOrderToColumnIdentifierMap.Length)
 02002            {
 02003                throw new ArgumentException("sortedColumnIDs array must be the same length as GetColumnCount.");
 2004            }
 2005
 02006            for (int i = 0; i < sortedColumnIDs.Length; i++)
 02007            {
 02008                AssertColumnIdentifierValid(sortedColumnIDs[i]);
 02009            }
 02010        }
 2011
 2012        internal void AssertColumnSortOrderValid(int sortedOrder)
 02013        {
 02014            if (sortedOrder >= m_CombinedColumnCount || sortedOrder < 0)
 02015            {
 02016                throw new ArgumentException("Invalid column sort order argument: " + sortedOrder);
 2017            }
 02018        }
 2019
 2020        internal void AssertRowSortOrderValid(int sortedOrder)
 02021        {
 02022            if (sortedOrder >= m_RowCount || sortedOrder < 0)
 02023            {
 02024                throw new ArgumentException("Invalid row sort order argument: " + sortedOrder);
 2025            }
 02026        }
 2027
 2028        internal void AssertSortRowsArgValid(int[] sortedRowIDs)
 02029        {
 02030            if (sortedRowIDs == null)
 02031            {
 02032                throw new ArgumentException("sortedRowIDs array cannot be null.");
 2033            }
 2034
 02035            if (sortedRowIDs.Length != m_RowDenseIndexToIDMap.Length)
 02036            {
 02037                throw new ArgumentException("sortedRowIDs array must be the same length as GetRowCount.");
 2038            }
 2039
 02040            for (int i = 0; i < sortedRowIDs.Length; i++)
 02041            {
 02042                AssertRowIdentifierValid(sortedRowIDs[i]);
 02043            }
 02044        }
 2045
 2046        [Serializable]
 2047        internal struct ColumnEntry
 2048        {
 2049            public Serializable.SerializableTypes ColumnType;
 2050            public int ColumnDenseIndex;
 2051        }
 2052    }
 2053}
Generated by: ReportGenerator 5.0.4.0
2024-01-01 - 7:00:19 PM
GitHub | www.palmmedia.de

Coverage by test methods












Methods/Properties

StableDataTable()
GetDataVersion()
GetStructureVersion()
GetStructureCurrentVersion()
Migrate(System.Int32)
GetColumnCount()
GetRowCount()
GetAllRowDescriptions()
GetRowDescription(System.Int32)
GetRowDescriptionByOrder(System.Int32)
GetColumnDescription(System.Int32)
GetColumnDescriptionByOrder(System.Int32)
GetAllColumnDescriptions()
AssertColumnIdentifierValid(System.Int32)
AssertRowIdentifierValid(System.Int32)
SetColumnName(System.Int32, System.String)
GetColumnName(System.Int32)
SetRowName(System.Int32, System.String)
GetRowName(System.Int32)
GetRowNameRef(System.Int32)
GetColumnNameRef(System.Int32)
AddRow(System.String, System.Int32)
AddRows(System.Int32, System.String[], System.Int32)
AddRows(System.Int32, System.Int32[]&, System.String[], System.Int32)
RemoveRow(System.Int32)
AddColumn(GDX.Serializable/SerializableTypes, System.String, System.Int32)
RemoveColumn(GDX.Serializable/SerializableTypes, System.Int32)
SetString(System.Int32, System.Int32, System.String)
SetBool(System.Int32, System.Int32, System.Boolean)
SetChar(System.Int32, System.Int32, System.Char)
SetSByte(System.Int32, System.Int32, System.SByte)
SetByte(System.Int32, System.Int32, System.Byte)
SetEnumInt(System.Int32, System.Int32, System.Int32)
SetShort(System.Int32, System.Int32, System.Int16)
SetUShort(System.Int32, System.Int32, System.UInt16)
SetInt(System.Int32, System.Int32, System.Int32)
SetUInt(System.Int32, System.Int32, System.UInt32)
SetLong(System.Int32, System.Int32, System.Int64)
SetULong(System.Int32, System.Int32, System.UInt64)
SetFloat(System.Int32, System.Int32, System.Single)
SetDouble(System.Int32, System.Int32, System.Double)
SetVector2(System.Int32, System.Int32, UnityEngine.Vector2)
SetVector3(System.Int32, System.Int32, UnityEngine.Vector3)
SetVector4(System.Int32, System.Int32, UnityEngine.Vector4)
SetVector2Int(System.Int32, System.Int32, UnityEngine.Vector2Int)
SetVector3Int(System.Int32, System.Int32, UnityEngine.Vector3Int)
SetQuaternion(System.Int32, System.Int32, UnityEngine.Quaternion)
SetRect(System.Int32, System.Int32, UnityEngine.Rect)
SetRectInt(System.Int32, System.Int32, UnityEngine.RectInt)
SetColor(System.Int32, System.Int32, UnityEngine.Color)
SetLayerMask(System.Int32, System.Int32, UnityEngine.LayerMask)
SetBounds(System.Int32, System.Int32, UnityEngine.Bounds)
SetBoundsInt(System.Int32, System.Int32, UnityEngine.BoundsInt)
SetHash128(System.Int32, System.Int32, UnityEngine.Hash128)
SetGradient(System.Int32, System.Int32, UnityEngine.Gradient)
SetAnimationCurve(System.Int32, System.Int32, UnityEngine.AnimationCurve)
SetObject(System.Int32, System.Int32, UnityEngine.Object)
SetTypeNameForColumn(System.Int32, System.String)
GetTypeNameForColumn(System.Int32)
GetString(System.Int32, System.Int32)
GetBool(System.Int32, System.Int32)
GetChar(System.Int32, System.Int32)
GetEnumInt(System.Int32, System.Int32)
GetSByte(System.Int32, System.Int32)
GetByte(System.Int32, System.Int32)
GetShort(System.Int32, System.Int32)
GetUShort(System.Int32, System.Int32)
GetInt(System.Int32, System.Int32)
GetUInt(System.Int32, System.Int32)
GetLong(System.Int32, System.Int32)
GetULong(System.Int32, System.Int32)
GetFloat(System.Int32, System.Int32)
GetDouble(System.Int32, System.Int32)
GetVector2(System.Int32, System.Int32)
GetVector3(System.Int32, System.Int32)
GetVector4(System.Int32, System.Int32)
GetVector2Int(System.Int32, System.Int32)
GetVector3Int(System.Int32, System.Int32)
GetQuaternion(System.Int32, System.Int32)
GetRect(System.Int32, System.Int32)
GetRectInt(System.Int32, System.Int32)
GetColor(System.Int32, System.Int32)
GetLayerMask(System.Int32, System.Int32)
GetBounds(System.Int32, System.Int32)
GetBoundsInt(System.Int32, System.Int32)
GetHash128(System.Int32, System.Int32)
GetGradient(System.Int32, System.Int32)
GetAnimationCurve(System.Int32, System.Int32)
GetObject(System.Int32, System.Int32)
GetStringRef(System.Int32, System.Int32)
GetBoolRef(System.Int32, System.Int32)
GetCharRef(System.Int32, System.Int32)
GetSbyteRef(System.Int32, System.Int32)
GetByteRef(System.Int32, System.Int32)
GetShortRef(System.Int32, System.Int32)
GetUshortRef(System.Int32, System.Int32)
GetIntRef(System.Int32, System.Int32)
GetUintRef(System.Int32, System.Int32)
GetLongRef(System.Int32, System.Int32)
GetUlongRef(System.Int32, System.Int32)
GetFloatRef(System.Int32, System.Int32)
GetDoubleRef(System.Int32, System.Int32)
GetVector2Ref(System.Int32, System.Int32)
GetVector3Ref(System.Int32, System.Int32)
GetVector4Ref(System.Int32, System.Int32)
GetVector2IntRef(System.Int32, System.Int32)
GetVector3IntRef(System.Int32, System.Int32)
GetQuaternionRef(System.Int32, System.Int32)
GetRectRef(System.Int32, System.Int32)
GetRectIntRef(System.Int32, System.Int32)
GetColorRef(System.Int32, System.Int32)
GetLayerMaskRef(System.Int32, System.Int32)
GetBoundsRef(System.Int32, System.Int32)
GetBoundsIntRef(System.Int32, System.Int32)
GetHash128Ref(System.Int32, System.Int32)
GetGradientRef(System.Int32, System.Int32)
GetAnimationCurveRef(System.Int32, System.Int32)
GetObjectRef(System.Int32, System.Int32)
GetStringColumn(System.Int32)
GetBoolColumn(System.Int32)
GetCharColumn(System.Int32)
GetSbyteColumn(System.Int32)
GetByteColumn(System.Int32)
GetShortColumn(System.Int32)
GetUshortColumn(System.Int32)
GetIntColumn(System.Int32)
GetUintColumn(System.Int32)
GetLongColumn(System.Int32)
GetUlongColumn(System.Int32)
GetFloatColumn(System.Int32)
GetDoubleColumn(System.Int32)
GetVector2Column(System.Int32)
GetVector3Column(System.Int32)
GetVector4Column(System.Int32)
GetVector2IntColumn(System.Int32)
GetVector3IntColumn(System.Int32)
GetQuaternionColumn(System.Int32)
GetRectColumn(System.Int32)
GetRectIntColumn(System.Int32)
GetColorColumn(System.Int32)
GetLayerMaskColumn(System.Int32)
GetBoundsColumn(System.Int32)
GetBoundsIntColumn(System.Int32)
GetHash128Column(System.Int32)
GetGradientColumn(System.Int32)
GetAnimationCurveColumn(System.Int32)
GetObjectColumn(System.Int32)
GetColumnOrder(System.Int32)
SetColumnOrder(System.Int32, System.Int32)
SetAllColumnOrders(System.Int32[])
GetRowOrder(System.Int32)
SetRowOrder(System.Int32, System.Int32)
SetAllRowOrders(System.Int32[])
ReSortRows[T](, System.Int32[])
AddTypeNameEntry(System.String[]&, System.String)
RemoveTypeNameEntry(System.Int32, System.String[]&)
AddColumnInternal[T](System.String, , GDX.Serializable/SerializableTypes, System.Int32)
RemoveColumnInternal[T](, GDX.Serializable/SerializableTypes, System.Int32)
InsertRowsOfTypeInternal[T](, System.Int32, System.Int32)
DeleteRowsOfTypeInternal[T](, System.Int32, System.Int32)
GetCellRef[T](System.Int32, System.Int32, )
GetCell[T](System.Int32, System.Int32, )
SetCell[T](System.Int32, System.Int32, , T)
GetColumn[T](System.Int32, )
SetRowOrderForColumns[T](, System.Int32, System.Int32)
AssertSortedColumnsArgValid(System.Int32[])
AssertColumnSortOrderValid(System.Int32)
AssertRowSortOrderValid(System.Int32)
AssertSortRowsArgValid(System.Int32[])