9639235584

Committed 24 Jun 2024 03:44AM UTC coverage: 79.973% (-1.0%) from 80.969%

Build # 9639235584

Build Type

push

github

Committed by

JaCraig

Commit Message

fix: Fixing issue with tests and CopyTo

Run Details

1037 of 1370 branches covered (75.69%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 2 files covered. (100.0%)

113 existing lines in 5 files now uncovered.

1343 of 1606 relevant lines covered (83.62%)

7313.32 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.24

/Archivist/DataTypes/Table.cs

﻿using Archivist.BaseClasses;
using Archivist.Interfaces;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Dynamic;
using System.Text;

namespace Archivist.DataTypes
{
    /// <summary>
    /// Represents a table in the Archivist system.
    /// </summary>
    /// <seealso cref="FileBaseClass{Table}"/>
    public class Table : FileBaseClass<Table>, IComparable<Table>, IEquatable<Table>, IListConvertable, IList<TableRow>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Table"/> class.
        /// </summary>
        public Table()
        {
            Delimiter = ",";
        }

        /// <summary>
        /// Gets the headers of the table.
        /// </summary>
        /// <value>The headers.</value>
        public List<string> Columns { get; } = new List<string>();

        /// <summary>
        /// Gets the number of rows in the table.
        /// </summary>
        public int Count => Rows.Count;

        /// <summary>
        /// Gets or sets the delimiter used by the table.
        /// </summary>
        public string Delimiter
        {
            get
            {
                _ = Metadata.TryGetValue("Delimiter", out var Delimiter);
                return Delimiter ?? ",";
            }
            set => Metadata["Delimiter"] = value;
        }

        /// <summary>
        /// Gets a value indicating whether the table is read-only.
        /// </summary>
        public bool IsReadOnly => false;

        /// <summary>
        /// Gets the rows of the table.
        /// </summary>
        private List<TableRow> Rows { get; } = new List<TableRow>();

        /// <summary>
        /// Gets or sets the row at the specified index.
        /// </summary>
        /// <param name="index">The index of the table.</param>
        /// <returns>The row at the specified index.</returns>
        /// <exception cref="ArgumentOutOfRangeException">The index is out of range.</exception>
        public TableRow this[int index]
        {
            get
            {
                if (index < 0 || index >= Rows.Count)
                    throw new ArgumentOutOfRangeException(nameof(index));
                return Rows[index];
            }
            set
            {
                if (index < 0 || index >= Rows.Count)
                    throw new ArgumentOutOfRangeException(nameof(index));
                Rows[index] = value ?? new TableRow(Columns);
            }
        }

        /// <summary>
        /// Converts the table to a card.
        /// </summary>
        /// <param name="file">The table to convert.</param>
        /// <returns>The card representation of the table.</returns>
        public static implicit operator Card?(Table? file)
        {
            if (file is null)
                return null;
            var ReturnValue = new Card() { Title = file.Title };
            if (file.Count == 0 || file.Columns.Count == 0)
                return ReturnValue;
            foreach (var Column in file.Columns)
            {
                ReturnValue.Fields.Add(new CardField(Column, Array.Empty<CardFieldParameter>(), file[0][Column].Content));
            }
            foreach (KeyValuePair<string, string> Metadata in file.Metadata)
            {
                ReturnValue.Metadata.Add(Metadata.Key, Metadata.Value);
            }
            return ReturnValue;
        }

        /// <summary>
        /// Converts the table to a structured object.
        /// </summary>
        /// <param name="file">The table to convert.</param>
        public static implicit operator StructuredObject?(Table? file)
        {
            if (file is null)
                return null;
            IDictionary<string, object?> ContentObject = new ExpandoObject();
            foreach (var Column in file.Columns)
            {
                var ColumnList = new List<object>();
                ContentObject.Add(Column, ColumnList);
                foreach (TableRow Row in file.Rows)
                {
                    var Content = Row[Column]?.Content;
                    if (string.IsNullOrEmpty(Content))
                        continue;
                    ColumnList.Add(Content);
                }
            }
            var ReturnValue = new StructuredObject(ContentObject);
            foreach (KeyValuePair<string, string> Metadata in file.Metadata)
            {
                ReturnValue.Metadata.Add(Metadata.Key, Metadata.Value);
            }
            ReturnValue.Title = file.Title;
            return ReturnValue;
        }

        /// <summary>
        /// Converts the table to a tables object.
        /// </summary>
        /// <param name="file">The table to convert.</param>
        /// <returns>The tables representation of the table.</returns>
        public static implicit operator Tables?(Table? file)
        {
            if (file is null)
                return null;
            var ReturnValue = new Tables
            {
                file
            };
            foreach (KeyValuePair<string, string> Metadata in file.Metadata)
            {
                ReturnValue.Metadata.Add(Metadata.Key, Metadata.Value);
            }
            ReturnValue.Title = file.Title;
            return ReturnValue;
        }

        /// <summary>
        /// Converts the table to a text object.
        /// </summary>
        /// <param name="file">The table to convert.</param>
        /// <returns>The text representation of the table.</returns>
        public static implicit operator Text?(Table? file)
        {
            if (file is null)
                return null;
            var ReturnValue = new Text(file.GetContent(), file.Title);
            foreach (KeyValuePair<string, string> Metadata in file.Metadata)
            {
                ReturnValue.Metadata.Add(Metadata.Key, Metadata.Value);
            }
            return ReturnValue;
        }

        /// <summary>
        /// Determines whether two table objects are not equal.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns><c>true</c> if the two table objects are not equal; otherwise, <c>false</c>.</returns>
        public static bool operator !=(Table? left, Table? right)
        {
            return !(left == right);
        }

        /// <summary>
        /// Determines whether the first table object is less than the second table object.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns>
        /// <c>true</c> if the first table object is less than the second table object; otherwise, <c>false</c>.
        /// </returns>
        public static bool operator <(Table? left, Table? right)
        {
            return left is null ? right is not null : left.CompareTo(right) < 0;
        }

        /// <summary>
        /// Determines whether the first table object is less than or equal to the second table object.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns>
        /// <c>true</c> if the first table object is less than or equal to the second table object;
        /// otherwise, <c>false</c>.
        /// </returns>
        public static bool operator <=(Table? left, Table? right)
        {
            return left is null || left.CompareTo(right) <= 0;
        }

        /// <summary>
        /// Determines whether two table objects are equal.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns><c>true</c> if the two table objects are equal; otherwise, <c>false</c>.</returns>
        public static bool operator ==(Table? left, Table? right)
        {
            if (left is null)
                return right is null;
            return left.Equals(right);
        }

        /// <summary>
        /// Determines whether the first table object is greater than the second table object.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns>
        /// <c>true</c> if the first table object is greater than the second table object;
        /// otherwise, <c>false</c>.
        /// </returns>
        public static bool operator >(Table? left, Table? right)
        {
            return left?.CompareTo(right) > 0;
        }

        /// <summary>
        /// Determines whether the first table object is greater than or equal to the second table object.
        /// </summary>
        /// <param name="left">The first table object.</param>
        /// <param name="right">The second table object.</param>
        /// <returns>
        /// <c>true</c> if the first table object is greater than or equal to the second table
        /// object; otherwise, <c>false</c>.
        /// </returns>
        public static bool operator >=(Table? left, Table? right)
        {
            return left is null ? right is null : left.CompareTo(right) >= 0;
        }

        /// <summary>
        /// Adds a row to the table.
        /// </summary>
        /// <param name="item">The row to add to the table.</param>
        public void Add(TableRow? item) => Rows.Add(item ?? new TableRow(Columns));

        /// <summary>
        /// Adds a new row to the table.
        /// </summary>
        /// <returns>The new row.</returns>
        public TableRow AddRow()
        {
            var Row = new TableRow(Columns);
            Rows.Add(Row);
            return Row;
        }

        /// <summary>
        /// Clears the table.
        /// </summary>
        public void Clear() => Rows.Clear();

        /// <summary>
        /// Compares the current table object with another table object.
        /// </summary>
        /// <param name="other">The table object to compare with this table object.</param>
        /// <returns>A value that indicates the relative order of the table objects being compared.</returns>
        public override int CompareTo(Table? other)
        {
            if (other is null)
                return 1;
            return other.GetContent()?.CompareTo(GetContent()) ?? 1;
        }

        /// <summary>
        /// Determines if the table contains the specified row.
        /// </summary>
        /// <param name="item">The row to find in the table.</param>
        /// <returns><c>true</c> if the table contains the row; otherwise, <c>false&gt;</c>.</returns>
        public bool Contains(TableRow? item) => item is not null && Rows.Contains(item);

        /// <summary>
        /// Copies the list object to the table.
        /// </summary>
        /// <typeparam name="TObject">The type of the object.</typeparam>
        /// <param name="obj">The list object to copy to the table.</param>
        public void ConvertFrom<TObject>(List<TObject?> obj)
        {
            obj ??= new List<TObject?>();
            Columns.Clear();
            Rows.Clear();
            foreach (System.Reflection.PropertyInfo Property in typeof(TObject).GetProperties())
            {
                Columns.Add(Property.Name);
            }
            foreach (TObject? Item in obj)
            {
                var Row = new TableRow(Columns);
                Row.ConvertFrom(Item);
                Rows.Add(Row);
            }
        }

        /// <summary>
        /// Converts this instance into the object array of the type specified.
        /// </summary>
        /// <typeparam name="TObject">The type of the object.</typeparam>
        /// <returns>The resulting array.</returns>
        public List<TObject?> ConvertTo<TObject>() => Rows.ConvertAll(x => x.ConvertTo<TObject?>());

        /// <summary>
        /// Copies the rows of the table to an array, starting at a particular array index.
        /// </summary>
        /// <param name="array">The array to copy the rows to.</param>
        /// <param name="arrayIndex">The index in the array at which to start copying the rows.</param>
        public void CopyTo(TableRow[]? array, int arrayIndex)
        {
            if (array is null || array.Length == 0)
                return;
            if (arrayIndex < 0 || arrayIndex >= array.Length)
                throw new ArgumentOutOfRangeException(nameof(arrayIndex));
            var Count = Math.Min(array.Length - arrayIndex, Rows.Count);
            Rows.CopyTo(0, array, arrayIndex, Count);
        }

        /// <summary>
        /// Determines whether the current table object is equal to another table object.
        /// </summary>
        /// <param name="obj">The table object to compare with this table object.</param>
        /// <returns>
        /// <c>true</c> if the current table object is equal to the other table object; otherwise, <c>false</c>.
        /// </returns>
        public override bool Equals(object? obj) => obj is Table Table && Equals(Table);

        /// <summary>
        /// Determines whether the current table object is equal to another table object.
        /// </summary>
        /// <param name="other">The table object to compare with this table object.</param>
        /// <returns>
        /// <c>true</c> if the current table object is equal to the other table object; otherwise, <c>false</c>.
        /// </returns>
        public override bool Equals(Table? other)
        {
            if (ReferenceEquals(this, other))
                return true;
            if (other is null)
                return false;
            return GetContent() == other.GetContent();
        }

        /// <summary>
        /// Gets the content of the table.
        /// </summary>
        /// <returns>The content of the table.</returns>
        public override string? GetContent()
        {
            return new StringBuilder()
                    .AppendJoin(' ', Columns)
                    .Append('\n')
                    .AppendJoin('\n', Rows)
                    .ToString();
        }

        /// <summary>
        /// Returns an enumerator that iterates through the rows of the table.
        /// </summary>
        /// <returns>An enumerator that can be used to iterate through the rows of the table.</returns>
        public IEnumerator<TableRow> GetEnumerator() => Rows.GetEnumerator();

        /// <summary>
        /// Returns an enumerator that iterates through the rows of the table.
        /// </summary>
        /// <returns>An enumerator that can be used to iterate through the rows of the table.</returns>
        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

        /// <summary>
        /// Returns the hash code for the current table object.
        /// </summary>
        /// <returns>A hash code for the current table object.</returns>
        public override int GetHashCode()
        {
            var HashCode = new HashCode();
            foreach (var Column in Columns)
            {
                HashCode.Add(Column);
            }
            foreach (TableRow Row in Rows)
            {
                HashCode.Add(Row);
            }
            return HashCode.ToHashCode();
        }

        /// <summary>
        /// Returns the index of the specified row in the table.
        /// </summary>
        /// <param name="item">The row to find in the table.</param>
        /// <returns>The index of the row in the table.</returns>
        public int IndexOf(TableRow? item) => Rows.IndexOf(item!);

        /// <summary>
        /// Inserts a row into the table at the specified index.
        /// </summary>
        /// <param name="index">The index at which to insert the row.</param>
        /// <param name="item">The row to insert into the table.</param>
        public void Insert(int index, TableRow? item)
        {
            if (index < 0)
                index = 0;
            if (index > Count)
                index = Count;
            item ??= new TableRow(Columns);
            Rows.Insert(index, item);
        }

        /// <summary>
        /// Removes the first occurrence of a specific row from the table.
        /// </summary>
        /// <param name="item">The row to remove from the table.</param>
        /// <returns><c>true</c> if the row was successfully removed; otherwise, <c>false&gt;</c>.</returns>
        public bool Remove(TableRow? item) => item is not null && Rows.Remove(item);

        /// <summary>
        /// Removes the row at the specified index.
        /// </summary>
        /// <param name="index">The index of the row to remove.</param>
        public void RemoveAt(int index)
        {
            if (index < 0 || index >= Count)
                return;
            Rows.RemoveAt(index);
        }

        /// <summary>
        /// Converts the table to the specified file type.
        /// </summary>
        /// <typeparam name="TFile">The type of the file.</typeparam>
        /// <returns>The file of the specified type.</returns>
        public override TFile? ToFileType<TFile>() where TFile : default
        {
            Type FileType = typeof(TFile);
            IGenericFile? ReturnValue = null;
            if (FileType == typeof(Card))
                ReturnValue = (Card?)this;
            else if (FileType == typeof(Table))
                ReturnValue = this;
            else if (FileType == typeof(Tables))
                ReturnValue = (Tables?)this;
            else if (FileType == typeof(Text))
                ReturnValue = (Text?)this;
            else if (FileType == typeof(StructuredObject))
                ReturnValue = (StructuredObject?)this;

            return (TFile?)ReturnValue;
        }
    }
}

1	using Archivist.BaseClasses;
2	using Archivist.Interfaces;
3	using System;
4	using System.Collections;
5	using System.Collections.Generic;
6	using System.Dynamic;
7	using System.Text;
8
9	namespace Archivist.DataTypes
10	{
11	/// <summary>
12	/// Represents a table in the Archivist system.
13	/// </summary>
14	/// <seealso cref="FileBaseClass{Table}"/>
15	public class Table : FileBaseClass<Table>, IComparable<Table>, IEquatable<Table>, IListConvertable, IList<TableRow>
16	{
17	/// <summary>
18	/// Initializes a new instance of the <see cref="Table"/> class.
19	/// </summary>
20	public Table()	7,726✔
21	{
22	Delimiter = ",";	7,726✔
23	}	7,726✔
24
25	/// <summary>
26	/// Gets the headers of the table.
27	/// </summary>
28	/// <value>The headers.</value>
29	public List<string> Columns { get; } = new List<string>();	379,018✔
30
31	/// <summary>
32	/// Gets the number of rows in the table.
33	/// </summary>
34	public int Count => Rows.Count;	49✔
35
36	/// <summary>
37	/// Gets or sets the delimiter used by the table.
38	/// </summary>
39	public string Delimiter
40	{
41	get
42	{
43	_ = Metadata.TryGetValue("Delimiter", out var Delimiter);	7✔
44	return Delimiter ?? ",";	7!
45	}
46	set => Metadata["Delimiter"] = value;	7,737✔
47	}
48
49	/// <summary>
50	/// Gets a value indicating whether the table is read-only.
51	/// </summary>
52	public bool IsReadOnly => false;	2✔
53
54	/// <summary>
55	/// Gets the rows of the table.
56	/// </summary>
57	private List<TableRow> Rows { get; } = new List<TableRow>();	436,713✔
58
59	/// <summary>
60	/// Gets or sets the row at the specified index.
61	/// </summary>
62	/// <param name="index">The index of the table.</param>
63	/// <returns>The row at the specified index.</returns>
64	/// <exception cref="ArgumentOutOfRangeException">The index is out of range.</exception>
65	public TableRow this[int index]
66	{
67	get
68	{
69	if (index < 0 \|\| index >= Rows.Count)	100✔
70	throw new ArgumentOutOfRangeException(nameof(index));	10✔
71	return Rows[index];	90✔
72	}
73	set
74	{
75	if (index < 0 \|\| index >= Rows.Count)	11✔
76	throw new ArgumentOutOfRangeException(nameof(index));	10✔
77	Rows[index] = value ?? new TableRow(Columns);	1!
78	}	1✔
79	}
80
81	/// <summary>
82	/// Converts the table to a card.
83	/// </summary>
84	/// <param name="file">The table to convert.</param>
85	/// <returns>The card representation of the table.</returns>
86	public static implicit operator Card?(Table? file)
87	{
88	if (file is null)	12✔
89	return null;	1✔
90	var ReturnValue = new Card() { Title = file.Title };	11✔
91	if (file.Count == 0 \|\| file.Columns.Count == 0)	11✔
92	return ReturnValue;	9✔
93	foreach (var Column in file.Columns)	8✔
94	{
95	ReturnValue.Fields.Add(new CardField(Column, Array.Empty<CardFieldParameter>(), file[0][Column].Content));	2✔
96	}
97	foreach (KeyValuePair<string, string> Metadata in file.Metadata)	12✔
98	{
99	ReturnValue.Metadata.Add(Metadata.Key, Metadata.Value);	4✔
100	}
101	return ReturnValue;	2✔
102	}
103
104	/// <summary>
105	/// Converts the table to a structured object.
106	/// </summary>
107	/// <param name="file">The table to convert.</param>
108	public static implicit operator StructuredObject?(Table? file)
109	{
110	if (file is null)	10✔
111	return null;	1✔
112	IDictionary<string, object?> ContentObject = new ExpandoObject();	9✔
113	foreach (var Column in file.Columns)	18!
114	{
115	var ColumnList = new List<object>();	×
116	ContentObject.Add(Column, ColumnList);	×
UNCOV 117	foreach (TableRow Row in file.Rows)	×
118	{
UNCOV 119	var Content = Row[Column]?.Content;	×
120	if (string.IsNullOrEmpty(Content))	×
121	continue;
UNCOV 122	ColumnList.Add(Content);	×
123	}
124	}
125	var ReturnValue = new StructuredObject(ContentObject);	9✔
126	foreach (KeyValuePair<string, string> Metadata in file.Metadata)	36✔
127	{
128	ReturnValue.Metadata.Add(Metadata.Key, Metadata.Value);	9✔
129	}
130	ReturnValue.Title = file.Title;	9✔
131	return ReturnValue;	9✔
132	}
133
134	/// <summary>
135	/// Converts the table to a tables object.
136	/// </summary>
137	/// <param name="file">The table to convert.</param>
138	/// <returns>The tables representation of the table.</returns>
139	public static implicit operator Tables?(Table? file)
140	{
141	if (file is null)	10✔
142	return null;	1✔
143	var ReturnValue = new Tables	9✔
144	{	9✔
145	file	9✔
146	};	9✔
147	foreach (KeyValuePair<string, string> Metadata in file.Metadata)	36✔
148	{
149	ReturnValue.Metadata.Add(Metadata.Key, Metadata.Value);	9✔
150	}
151	ReturnValue.Title = file.Title;	9✔
152	return ReturnValue;	9✔
153	}
154
155	/// <summary>
156	/// Converts the table to a text object.
157	/// </summary>
158	/// <param name="file">The table to convert.</param>
159	/// <returns>The text representation of the table.</returns>
160	public static implicit operator Text?(Table? file)
161	{
162	if (file is null)	11✔
163	return null;	1✔
164	var ReturnValue = new Text(file.GetContent(), file.Title);	10✔
165	foreach (KeyValuePair<string, string> Metadata in file.Metadata)	42✔
166	{
167	ReturnValue.Metadata.Add(Metadata.Key, Metadata.Value);	11✔
168	}
169	return ReturnValue;	10✔
170	}
171
172	/// <summary>
173	/// Determines whether two table objects are not equal.
174	/// </summary>
175	/// <param name="left">The first table object.</param>
176	/// <param name="right">The second table object.</param>
177	/// <returns><c>true</c> if the two table objects are not equal; otherwise, <c>false</c>.</returns>
178	public static bool operator !=(Table? left, Table? right)
179	{
180	return !(left == right);	15✔
181	}
182
183	/// <summary>
184	/// Determines whether the first table object is less than the second table object.
185	/// </summary>
186	/// <param name="left">The first table object.</param>
187	/// <param name="right">The second table object.</param>
188	/// <returns>
189	/// <c>true</c> if the first table object is less than the second table object; otherwise, <c>false</c>.
190	/// </returns>
191	public static bool operator <(Table? left, Table? right)
192	{
193	return left is null ? right is not null : left.CompareTo(right) < 0;	13✔
194	}
195
196	/// <summary>
197	/// Determines whether the first table object is less than or equal to the second table object.
198	/// </summary>
199	/// <param name="left">The first table object.</param>
200	/// <param name="right">The second table object.</param>
201	/// <returns>
202	/// <c>true</c> if the first table object is less than or equal to the second table object;
203	/// otherwise, <c>false</c>.
204	/// </returns>
205	public static bool operator <=(Table? left, Table? right)
206	{
207	return left is null \|\| left.CompareTo(right) <= 0;	13✔
208	}
209
210	/// <summary>
211	/// Determines whether two table objects are equal.
212	/// </summary>
213	/// <param name="left">The first table object.</param>
214	/// <param name="right">The second table object.</param>
215	/// <returns><c>true</c> if the two table objects are equal; otherwise, <c>false</c>.</returns>
216	public static bool operator ==(Table? left, Table? right)
217	{
218	if (left is null)	30✔
219	return right is null;	4✔
220	return left.Equals(right);	26✔
221	}
222
223	/// <summary>
224	/// Determines whether the first table object is greater than the second table object.
225	/// </summary>
226	/// <param name="left">The first table object.</param>
227	/// <param name="right">The second table object.</param>
228	/// <returns>
229	/// <c>true</c> if the first table object is greater than the second table object;
230	/// otherwise, <c>false</c>.
231	/// </returns>
232	public static bool operator >(Table? left, Table? right)
233	{
234	return left?.CompareTo(right) > 0;	13✔
235	}
236
237	/// <summary>
238	/// Determines whether the first table object is greater than or equal to the second table object.
239	/// </summary>
240	/// <param name="left">The first table object.</param>
241	/// <param name="right">The second table object.</param>
242	/// <returns>
243	/// <c>true</c> if the first table object is greater than or equal to the second table
244	/// object; otherwise, <c>false</c>.
245	/// </returns>
246	public static bool operator >=(Table? left, Table? right)
247	{
248	return left is null ? right is null : left.CompareTo(right) >= 0;	13✔
249	}
250
251	/// <summary>
252	/// Adds a row to the table.
253	/// </summary>
254	/// <param name="item">The row to add to the table.</param>
255	public void Add(TableRow? item) => Rows.Add(item ?? new TableRow(Columns));	370,415✔
256
257	/// <summary>
258	/// Adds a new row to the table.
259	/// </summary>
260	/// <returns>The new row.</returns>
261	public TableRow AddRow()
262	{
263	var Row = new TableRow(Columns);	59✔
264	Rows.Add(Row);	59✔
265	return Row;	59✔
266	}
267
268	/// <summary>
269	/// Clears the table.
270	/// </summary>
271	public void Clear() => Rows.Clear();	2✔
272
273	/// <summary>
274	/// Compares the current table object with another table object.
275	/// </summary>
276	/// <param name="other">The table object to compare with this table object.</param>
277	/// <returns>A value that indicates the relative order of the table objects being compared.</returns>
278	public override int CompareTo(Table? other)
279	{
280	if (other is null)	59✔
281	return 1;	9✔
282	return other.GetContent()?.CompareTo(GetContent()) ?? 1;	50!
283	}
284
285	/// <summary>
286	/// Determines if the table contains the specified row.
287	/// </summary>
288	/// <param name="item">The row to find in the table.</param>
289	/// <returns><c>true</c> if the table contains the row; otherwise, <c>false></c>.</returns>
290	public bool Contains(TableRow? item) => item is not null && Rows.Contains(item);	3✔
291
292	/// <summary>
293	/// Copies the list object to the table.
294	/// </summary>
295	/// <typeparam name="TObject">The type of the object.</typeparam>
296	/// <param name="obj">The list object to copy to the table.</param>
297	public void ConvertFrom<TObject>(List<TObject?> obj)
298	{
299	obj ??= new List<TObject?>();	12✔
300	Columns.Clear();	12✔
301	Rows.Clear();	12✔
302	foreach (System.Reflection.PropertyInfo Property in typeof(TObject).GetProperties())	30✔
303	{
304	Columns.Add(Property.Name);	3✔
305	}
306	foreach (TObject? Item in obj)	884✔
307	{
308	var Row = new TableRow(Columns);	430✔
309	Row.ConvertFrom(Item);	430✔
310	Rows.Add(Row);	430✔
311	}
312	}	12✔
313
314	/// <summary>
315	/// Converts this instance into the object array of the type specified.
316	/// </summary>
317	/// <typeparam name="TObject">The type of the object.</typeparam>
318	/// <returns>The resulting array.</returns>
319	public List<TObject?> ConvertTo<TObject>() => Rows.ConvertAll(x => x.ConvertTo<TObject?>());	7✔
320
321	/// <summary>
322	/// Copies the rows of the table to an array, starting at a particular array index.
323	/// </summary>
324	/// <param name="array">The array to copy the rows to.</param>
325	/// <param name="arrayIndex">The index in the array at which to start copying the rows.</param>
326	public void CopyTo(TableRow[]? array, int arrayIndex)
327	{
328	if (array is null \|\| array.Length == 0)	12✔
329	return;	4✔
330	if (arrayIndex < 0 \|\| arrayIndex >= array.Length)	8✔
331	throw new ArgumentOutOfRangeException(nameof(arrayIndex));	7✔
332	var Count = Math.Min(array.Length - arrayIndex, Rows.Count);	1✔
333	Rows.CopyTo(0, array, arrayIndex, Count);	1✔
334	}	1✔
335
336	/// <summary>
337	/// Determines whether the current table object is equal to another table object.
338	/// </summary>
339	/// <param name="obj">The table object to compare with this table object.</param>
340	/// <returns>
341	/// <c>true</c> if the current table object is equal to the other table object; otherwise, <c>false</c>.
342	/// </returns>
343	public override bool Equals(object? obj) => obj is Table Table && Equals(Table);	6✔
344
345	/// <summary>
346	/// Determines whether the current table object is equal to another table object.
347	/// </summary>
348	/// <param name="other">The table object to compare with this table object.</param>
349	/// <returns>
350	/// <c>true</c> if the current table object is equal to the other table object; otherwise, <c>false</c>.
351	/// </returns>
352	public override bool Equals(Table? other)
353	{
354	if (ReferenceEquals(this, other))	41!
UNCOV 355	return true;	×
356	if (other is null)	41✔
357	return false;	6✔
358	return GetContent() == other.GetContent();	35✔
359	}
360
361	/// <summary>
362	/// Gets the content of the table.
363	/// </summary>
364	/// <returns>The content of the table.</returns>
365	public override string? GetContent()
366	{
367	return new StringBuilder()	219✔
368	.AppendJoin(' ', Columns)	219✔
369	.Append('\n')	219✔
370	.AppendJoin('\n', Rows)	219✔
371	.ToString();	219✔
372	}
373
374	/// <summary>
375	/// Returns an enumerator that iterates through the rows of the table.
376	/// </summary>
377	/// <returns>An enumerator that can be used to iterate through the rows of the table.</returns>
378	public IEnumerator<TableRow> GetEnumerator() => Rows.GetEnumerator();	57,570✔
379
380	/// <summary>
381	/// Returns an enumerator that iterates through the rows of the table.
382	/// </summary>
383	/// <returns>An enumerator that can be used to iterate through the rows of the table.</returns>
384	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();	162✔
385
386	/// <summary>
387	/// Returns the hash code for the current table object.
388	/// </summary>
389	/// <returns>A hash code for the current table object.</returns>
390	public override int GetHashCode()
391	{
392	var HashCode = new HashCode();	10✔
393	foreach (var Column in Columns)	28✔
394	{
395	HashCode.Add(Column);	4✔
396	}
397	foreach (TableRow Row in Rows)	40✔
398	{
399	HashCode.Add(Row);	10✔
400	}
401	return HashCode.ToHashCode();	10✔
402	}
403
404	/// <summary>
405	/// Returns the index of the specified row in the table.
406	/// </summary>
407	/// <param name="item">The row to find in the table.</param>
408	/// <returns>The index of the row in the table.</returns>
409	public int IndexOf(TableRow? item) => Rows.IndexOf(item!);	3✔
410
411	/// <summary>
412	/// Inserts a row into the table at the specified index.
413	/// </summary>
414	/// <param name="index">The index at which to insert the row.</param>
415	/// <param name="item">The row to insert into the table.</param>
416	public void Insert(int index, TableRow? item)
417	{
418	if (index < 0)	12✔
419	index = 0;	5✔
420	if (index > Count)	12✔
421	index = Count;	4✔
422	item ??= new TableRow(Columns);	12✔
423	Rows.Insert(index, item);	12✔
424	}	12✔
425
426	/// <summary>
427	/// Removes the first occurrence of a specific row from the table.
428	/// </summary>
429	/// <param name="item">The row to remove from the table.</param>
430	/// <returns><c>true</c> if the row was successfully removed; otherwise, <c>false></c>.</returns>
431	public bool Remove(TableRow? item) => item is not null && Rows.Remove(item);	8✔
432
433	/// <summary>
434	/// Removes the row at the specified index.
435	/// </summary>
436	/// <param name="index">The index of the row to remove.</param>
437	public void RemoveAt(int index)
438	{
439	if (index < 0 \|\| index >= Count)	11✔
440	return;	9✔
441	Rows.RemoveAt(index);	2✔
442	}	2✔
443
444	/// <summary>
445	/// Converts the table to the specified file type.
446	/// </summary>
447	/// <typeparam name="TFile">The type of the file.</typeparam>
448	/// <returns>The file of the specified type.</returns>
449	public override TFile? ToFileType<TFile>() where TFile : default
450	{
451	Type FileType = typeof(TFile);	6✔
452	IGenericFile? ReturnValue = null;	6✔
453	if (FileType == typeof(Card))	6✔
454	ReturnValue = (Card?)this;	1✔
455	else if (FileType == typeof(Table))	5✔
456	ReturnValue = this;	4✔
457	else if (FileType == typeof(Tables))	1!
UNCOV 458	ReturnValue = (Tables?)this;	×
459	else if (FileType == typeof(Text))	1!
UNCOV 460	ReturnValue = (Text?)this;	×
461	else if (FileType == typeof(StructuredObject))	1!
UNCOV 462	ReturnValue = (StructuredObject?)this;	×
463
464	return (TFile?)ReturnValue;	6✔
465	}
466	}
467	}

JaCraig / Archivist / 9639235584

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous