10876738390

Committed 16 Sep 2024 02:49AM UTC coverage: 79.714% (-3.6%) from 83.305%

Build # 10876738390

Build Type

push

github

Committed by

web-flow

Commit Message

feat: Merge pull request #61 from JaCraig/AddingFeeds

Adding feeds

Run Details

2246 of 3048 branches covered (73.69%)

Branch coverage included in aggregate %.

697 of 898 new or added lines in 25 files covered. (77.62%)

2 existing lines in 2 files now uncovered.

2937 of 3454 relevant lines covered (85.03%)

11828.86 hits per line

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

85.96

/Archivist/DataTypes/Tables.cs

﻿using Archivist.BaseClasses;
using Archivist.Converters;
using Archivist.Interfaces;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Archivist.DataTypes
{
    /// <summary>
    /// Represents a collection of tables.
    /// </summary>
    /// <seealso cref="FileBaseClass{TFileType}"/>
    public class Tables : FileBaseClass<Tables>, IComparable<Tables>, IEquatable<Tables>, IListConvertable, IList<Table>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Tables"/> class.
        /// </summary>
        public Tables()
            : this(null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Tables"/> class.
        /// </summary>
        /// <param name="converter">The type converter.</param>
        public Tables(Convertinator? converter)
            : base(converter)
        {
        }

        /// <summary>
        /// The number of tables in the file.
        /// </summary>
        public int Count => TableEntries.Count;

        /// <summary>
        /// Is this file read only?
        /// </summary>
        public bool IsReadOnly => false;

        /// <summary>
        /// The table entries.
        /// </summary>
        private List<Table> TableEntries { get; } = new List<Table>();

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

        /// <summary>
        /// Converts the Tables to a Calendar.
        /// </summary>
        /// <param name="file">The Tables to convert.</param>
        public static implicit operator Calendar?(Tables? file)
        {
            return TablesToCalendarConverter.Convert(file);
        }

        /// <summary>
        /// Converts the Tables to a Card.
        /// </summary>
        /// <param name="file">The Tables to convert.</param>
        /// <returns>The Card converted from the Tables.</returns>
        public static implicit operator Card?(Tables? file)
        {
            return TablesToCardConverter.Convert(file);
        }

        /// <summary>
        /// Converts the Tables to a Feed.
        /// </summary>
        /// <param name="file">The Tables to convert.</param>
        /// <returns>The Feed converted from the Tables.</returns>
        public static implicit operator Feed?(Tables? file)
        {
            return TablesToFeedConverter.Convert(file);
        }

        /// <summary>
        /// Converts the Tables to a StructuredObject.
        /// </summary>
        /// <param name="file">The Tables to convert.</param>
        public static implicit operator StructuredObject?(Tables? file)
        {
            return TablesToStructuredObjectConverter.Convert(file);
        }

        /// <summary>
        /// Converts the Tables to a Table.
        /// </summary>
        /// <param name="file">The Tables to convert.</param>
        /// <returns>The Table converted from the Tables.</returns>
        public static implicit operator Table?(Tables? file)
        {
            return TablesToTableConverter.Convert(file);
        }

        /// <summary>
        /// Converts the Tables to a Text.
        /// </summary>
        /// <param name="file">The Tables to convert.</param>
        /// <returns>The Text converted from the Tables.</returns>
        public static implicit operator Text?(Tables? file)
        {
            return AnythingToTextConverter.Convert(file);
        }

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

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

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

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

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

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

        /// <summary>
        /// Adds a new table to the Table collection.
        /// </summary>
        /// <param name="item">The table to add to the collection.</param>
        public void Add(Table? item) => TableEntries.Add(item ?? new Table());

        /// <summary>
        /// Adds a new row to the Tables.
        /// </summary>
        /// <returns>The new row.</returns>
        public Table AddTable()
        {
            var NewTable = new Table();
            TableEntries.Add(NewTable);
            return NewTable;
        }

        /// <summary>
        /// Clears the tables.
        /// </summary>
        public void Clear() => TableEntries.Clear();

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

        /// <summary>
        /// Determines whether the Tables contains a specific table.
        /// </summary>
        /// <param name="item">The table to locate in the Tables.</param>
        /// <returns><c>true</c> if the table is found in the Tables; otherwise, <c>false</c>.</returns>
        public bool Contains(Table? item) => item is not null && TableEntries.Contains(item);

        /// <summary>
        /// Copies the list object to the Tables.
        /// </summary>
        /// <typeparam name="TObject">The type of the object.</typeparam>
        /// <param name="obj">The list object to copy to the Tables.</param>
        public void ConvertFrom<TObject>(List<TObject?>? obj)
        {
            obj ??= new List<TObject?>();
            if (obj.Count == 0)
                return;
            TableEntries.Clear();
            Table NewTable = AddTable();
            NewTable.ConvertFrom(obj);
        }

        /// <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>() => TableEntries.SelectMany(x => x.ConvertTo<TObject?>()).ToList();

        /// <summary>
        /// Copies the elements of the Tables to an array, starting at a particular array index.
        /// </summary>
        /// <param name="array">
        /// The one-dimensional array that is the destination of the elements copied from the Tables.
        /// </param>
        /// <param name="arrayIndex">The zero-based index in the array at which copying begins.</param>
        /// <exception cref="ArgumentNullException">Thrown when the array is null.</exception>
        public void CopyTo(Table[]? 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, TableEntries.Count);
            TableEntries.CopyTo(0, array, arrayIndex, Count);
        }

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

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

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

        /// <summary>
        /// Returns an enumerator that iterates through the Tables.
        /// </summary>
        /// <returns>An enumerator that can be used to iterate through the Tables.</returns>
        public IEnumerator<Table> GetEnumerator() => TableEntries.GetEnumerator();

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

        /// <summary>
        /// Returns the hash code for the current Tables object.
        /// </summary>
        /// <returns>A hash code for the current Tables object.</returns>
        public override int GetHashCode()
        {
            var HashCode = new HashCode();
            foreach (Table Table in TableEntries)
            {
                HashCode.Add(Table);
            }
            return HashCode.ToHashCode();
        }

        /// <summary>
        /// Gets the index of the specified table.
        /// </summary>
        /// <param name="item">The table to locate in the Tables.</param>
        /// <returns>The index of the table if found; otherwise, -1.</returns>
        public int IndexOf(Table? item) => TableEntries.IndexOf(item!);

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

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

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

        /// <summary>
        /// Converts the Tables 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;
            if (FileType == typeof(Card))
                ReturnValue = (Card?)this;
            else if (FileType == typeof(Calendar))
                ReturnValue = (Calendar?)this;
            else if (FileType == typeof(Tables))
                ReturnValue = this;
            else if (FileType == typeof(Table))
                ReturnValue = (Table?)this;
            else if (FileType == typeof(Feed))
                ReturnValue = (Feed?)this;
            else if (FileType == typeof(Text))
                ReturnValue = (Text?)this;
            else if (FileType == typeof(StructuredObject))
                ReturnValue = (StructuredObject?)this;
            else
                ReturnValue = (IGenericFile?)Converter?.Convert(this, FileType);

            return (TFile?)ReturnValue;
        }
    }
}

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

JaCraig / Archivist / 10876738390

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