< Summary

Class:	Azure.Search.Documents.Models.SearchModelFactory
Assembly:	Azure.Search.Documents
File(s):	C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Models\SearchModelFactory.cs C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Models\SearchResult{T}.cs C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Models\SearchResults{T}.cs C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Models\SearchSuggestion{T}.cs C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Models\SuggestResults{T}.cs
Covered lines:	0
Uncovered lines:	33
Coverable lines:	33
Total lines:	1072
Line coverage:	0% (0 of 33)
Covered branches:	0
Total branches:	0

Metrics

Method	Cyclomatic complexity	Line coverage	Branch coverage
AnalyzedTokenInfo(...)	-	0%	100%
IndexerExecutionResult(...)	-	0%	100%
SearchIndexerError(...)	-	0%	100%
SearchIndexerLimits(...)	-	0%	100%
SearchIndexerStatus(...)	-	0%	100%
SearchIndexerWarning(...)	-	0%	100%
SearchIndexStatistics(...)	-	0%	100%
SearchResourceCounter(...)	-	0%	100%
SearchServiceCounters(...)	-	0%	100%
SearchServiceLimits(...)	-	0%	100%
SearchServiceStatistics(...)	-	0%	100%
AutocompleteResults(...)	-	0%	100%
AutocompleteItem(...)	-	0%	100%
FacetResult(...)	-	0%	100%
IndexDocumentsResult(...)	-	0%	100%
IndexingResult(...)	-	0%	100%
SearchResult(...)	-	0%	100%
SearchResults(...)	-	0%	100%
SearchResultsPage(...)	-	0%	100%
SearchSuggestion(...)	-	0%	100%
SuggestResults(...)	-	0%	100%

File(s)

C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Models\SearchModelFactory.cs

	#	Line		Line coverage
		1		// Copyright (c) Microsoft Corporation. All rights reserved.
		2		// Licensed under the MIT License.
		3
		4		using System;
		5		using System.Collections.Generic;
		6		using Azure.Search.Documents.Indexes.Models;
		7
		8		namespace Azure.Search.Documents.Models
		9		{
		10		/// <summary>
		11		/// Helps mock the types in Azure.Search.Documents.Models.
		12		/// </summary>
		13		public static partial class SearchModelFactory
		14		{
		15		/// <summary> Initializes a new instance of AnalyzedTokenInfo. </summary>
		16		/// <param name="token"> The token returned by the analyzer. </param>
		17		/// <param name="startOffset"> The index of the first character of the token in the input text. </param>
		18		/// <param name="endOffset"> The index of the last character of the token in the input text. </param>
		19		/// <param name="position"> The position of the token in the input text relative to other tokens. The first toke
		20		/// <returns> A new AnalyzedTokenInfo instance for mocking. </returns>
		21		public static AnalyzedTokenInfo AnalyzedTokenInfo(
		22		string token,
		23		int startOffset,
		24		int endOffset,
		25		int position) =>
	0	26		new AnalyzedTokenInfo(token, startOffset, endOffset, position);
		27
		28		/// <summary> Initializes a new instance of IndexerExecutionResult. </summary>
		29		/// <param name="status"> The outcome of this indexer execution. </param>
		30		/// <param name="errorMessage"> The error message indicating the top-level error, if any. </param>
		31		/// <param name="startTime"> The start time of this indexer execution. </param>
		32		/// <param name="endTime"> The end time of this indexer execution, if the execution has already completed. </par
		33		/// <param name="errors"> The item-level indexing errors. </param>
		34		/// <param name="warnings"> The item-level indexing warnings. </param>
		35		/// <param name="itemCount"> The number of items that were processed during this indexer execution. This include
		36		/// <param name="failedItemCount"> The number of items that failed to be indexed during this indexer execution.
		37		/// <param name="initialTrackingState"> Change tracking state with which an indexer execution started. </param>
		38		/// <param name="finalTrackingState"> Change tracking state with which an indexer execution finished. </param>
		39		/// <returns> A new IndexerExecutionResult instance for mocking. </returns>
		40		public static IndexerExecutionResult IndexerExecutionResult(
		41		IndexerExecutionStatus status,
		42		string errorMessage,
		43		DateTimeOffset? startTime,
		44		DateTimeOffset? endTime,
		45		IReadOnlyList<SearchIndexerError> errors,
		46		IReadOnlyList<SearchIndexerWarning> warnings,
		47		int itemCount,
		48		int failedItemCount,
		49		string initialTrackingState,
		50		string finalTrackingState) =>
	0	51		new IndexerExecutionResult(status, errorMessage, startTime, endTime, errors, warnings, itemCount, failedItem
		52
		53		/// <summary> Initializes a new instance of SearchIndexerError. </summary>
		54		/// <param name="key"> The key of the item for which indexing failed. </param>
		55		/// <param name="errorMessage"> The message describing the error that occurred while processing the item. </para
		56		/// <param name="statusCode"> The status code indicating why the indexing operation failed. Possible values incl
		57		/// <param name="name"> The name of the source at which the error originated. For example, this could refer to a
		58		/// <param name="details"> Additional, verbose details about the error to assist in debugging the indexer. This
		59		/// <param name="documentationLink"> A link to a troubleshooting guide for these classes of errors. This may not
		60		/// <returns> A new SearchIndexerError instance for mocking. </returns>
		61		public static SearchIndexerError SearchIndexerError(
		62		string key,
		63		string errorMessage,
		64		int statusCode,
		65		string name,
		66		string details,
		67		string documentationLink) =>
	0	68		new SearchIndexerError(key, errorMessage, statusCode, name, details, documentationLink);
		69
		70		/// <summary> Initializes a new instance of SearchIndexerLimits. </summary>
		71		/// <param name="maxRunTime"> The maximum duration that the indexer is permitted to run for one execution. </par
		72		/// <param name="maxDocumentExtractionSize"> The maximum size of a document, in bytes, which will be considered
		73		/// <param name="maxDocumentContentCharactersToExtract"> The maximum number of characters that will be extracted
		74		/// <returns> A new SearchIndexerLimits instance for mocking. </returns>
		75		public static SearchIndexerLimits SearchIndexerLimits(
		76		TimeSpan? maxRunTime,
		77		long? maxDocumentExtractionSize,
		78		long? maxDocumentContentCharactersToExtract) =>
	0	79		new SearchIndexerLimits(maxRunTime, maxDocumentExtractionSize, maxDocumentContentCharactersToExtract);
		80
		81		/// <summary> Initializes a new instance of SearchIndexerStatus. </summary>
		82		/// <param name="status"> Overall indexer status. </param>
		83		/// <param name="lastResult"> The result of the most recent or an in-progress indexer execution. </param>
		84		/// <param name="executionHistory"> History of the recent indexer executions, sorted in reverse chronological or
		85		/// <param name="limits"> The execution limits for the indexer. </param>
		86		/// <returns> A new SearchIndexerStatus instance for mocking. </returns>
		87		public static SearchIndexerStatus SearchIndexerStatus(
		88		IndexerStatus status,
		89		IndexerExecutionResult lastResult,
		90		IReadOnlyList<IndexerExecutionResult> executionHistory,
		91		SearchIndexerLimits limits) =>
	0	92		new SearchIndexerStatus(status, lastResult, executionHistory, limits);
		93
		94		/// <summary> Initializes a new instance of SearchIndexerWarning. </summary>
		95		/// <param name="key"> The key of the item which generated a warning. </param>
		96		/// <param name="message"> The message describing the warning that occurred while processing the item. </param>
		97		/// <param name="name"> The name of the source at which the warning originated. For example, this could refer to
		98		/// <param name="details"> Additional, verbose details about the warning to assist in debugging the indexer. Thi
		99		/// <param name="documentationLink"> A link to a troubleshooting guide for these classes of warnings. This may n
		100		/// <returns> A new SearchIndexerWarning instance for mocking. </returns>
		101		public static SearchIndexerWarning SearchIndexerWarning(
		102		string key,
		103		string message,
		104		string name,
		105		string details,
		106		string documentationLink) =>
	0	107		new SearchIndexerWarning(key, message, name, details, documentationLink);
		108
		109		/// <summary> Initializes a new instance of SearchIndexStatistics. </summary>
		110		/// <param name="documentCount"> The number of documents in the index. </param>
		111		/// <param name="storageSize"> The amount of storage in bytes consumed by the index. </param>
		112		/// <returns> A new SearchIndexStatistics instance for mocking. </returns>
		113		public static SearchIndexStatistics SearchIndexStatistics(
		114		long documentCount,
		115		long storageSize) =>
	0	116		new SearchIndexStatistics(documentCount, storageSize);
		117
		118		/// <summary> Initializes a new instance of SearchResourceCounter. </summary>
		119		/// <param name="usage"> The resource usage amount. </param>
		120		/// <param name="quota"> The resource amount quota. </param>
		121		/// <returns> A new SearchResourceCounter instance for mocking. </returns>
		122		public static SearchResourceCounter SearchResourceCounter(
		123		long usage,
		124		long? quota) =>
	0	125		new SearchResourceCounter(usage, quota);
		126
		127		/// <summary> Initializes a new instance of SearchServiceCounters. </summary>
		128		/// <param name="documentCounter"> Total number of documents across all indexes in the service. </param>
		129		/// <param name="indexCounter"> Total number of indexes. </param>
		130		/// <param name="indexerCounter"> Total number of indexers. </param>
		131		/// <param name="dataSourceCounter"> Total number of data sources. </param>
		132		/// <param name="storageSizeCounter"> Total size of used storage in bytes. </param>
		133		/// <param name="synonymMapCounter"> Total number of synonym maps. </param>
		134		/// <returns> A new SearchServiceCounters instance for mocking. </returns>
		135		public static SearchServiceCounters SearchServiceCounters(
		136		SearchResourceCounter documentCounter,
		137		SearchResourceCounter indexCounter,
		138		SearchResourceCounter indexerCounter,
		139		SearchResourceCounter dataSourceCounter,
		140		SearchResourceCounter storageSizeCounter,
		141		SearchResourceCounter synonymMapCounter) =>
	0	142		new SearchServiceCounters(documentCounter, indexCounter, indexerCounter, dataSourceCounter, storageSizeCount
		143
		144		/// <summary> Initializes a new instance of SearchServiceLimits. </summary>
		145		/// <param name="maxFieldsPerIndex"> The maximum allowed fields per index. </param>
		146		/// <param name="maxFieldNestingDepthPerIndex"> The maximum depth which you can nest sub-fields in an index, inc
		147		/// <param name="maxComplexCollectionFieldsPerIndex"> The maximum number of fields of type Collection(Edm.Comple
		148		/// <param name="maxComplexObjectsInCollectionsPerDocument"> The maximum number of objects in complex collection
		149		/// <returns> A new SearchServiceLimits instance for mocking. </returns>
		150		public static SearchServiceLimits SearchServiceLimits(
		151		int? maxFieldsPerIndex,
		152		int? maxFieldNestingDepthPerIndex,
		153		int? maxComplexCollectionFieldsPerIndex,
		154		int? maxComplexObjectsInCollectionsPerDocument) =>
	0	155		new SearchServiceLimits(maxFieldsPerIndex, maxFieldNestingDepthPerIndex, maxComplexCollectionFieldsPerIndex,
		156
		157		/// <summary> Initializes a new instance of SearchServiceStatistics. </summary>
		158		/// <param name="counters"> Service level resource counters. </param>
		159		/// <param name="limits"> Service level general limits. </param>
		160		/// <returns> A new SearchServiceStatistics instance for mocking. </returns>
		161		public static SearchServiceStatistics SearchServiceStatistics(
		162		SearchServiceCounters counters,
		163		SearchServiceLimits limits) =>
	0	164		new SearchServiceStatistics(counters, limits);
		165
		166		/// <summary> Initializes a new instance of AutocompleteResults. </summary>
		167		/// <param name="coverage"> A value indicating the percentage of the index that was considered by the autocomple
		168		/// <param name="results"> The list of returned Autocompleted items. </param>
		169		/// <returns> A new AutocompleteResults instance for mocking. </returns>
		170		public static AutocompleteResults AutocompleteResults(
		171		double? coverage,
		172		IReadOnlyList<AutocompleteItem> results) =>
	0	173		new AutocompleteResults(coverage, results);
		174
		175		/// <summary> Initializes a new instance of AutocompleteItem. </summary>
		176		/// <param name="text"> The completed term. </param>
		177		/// <param name="queryPlusText"> The query along with the completed term. </param>
		178		/// <returns> A new AutocompleteItem instance for mocking. </returns>
		179		public static AutocompleteItem AutocompleteItem(
		180		string text,
		181		string queryPlusText) =>
	0	182		new AutocompleteItem(text, queryPlusText);
		183
		184		/// <summary> Initializes a new instance of FacetResult. </summary>
		185		/// <param name="count"> The approximate count of documents falling within the bucket described by this facet. <
		186		/// <param name="additionalProperties"> . </param>
		187		/// <returns> A new FacetResult instance for mocking. </returns>
		188		public static FacetResult FacetResult(
		189		long? count,
		190		IReadOnlyDictionary<string, object> additionalProperties) =>
	0	191		new FacetResult(count, additionalProperties);
		192
		193		/// <summary> Initializes a new instance of IndexDocumentsResult. </summary>
		194		/// <param name="results"> The list of status information for each document in the indexing request. </param>
		195		/// <returns> A new IndexDocumentsResult instance for mocking. </returns>
		196		public static IndexDocumentsResult IndexDocumentsResult(
		197		IEnumerable<IndexingResult> results) =>
	0	198		new IndexDocumentsResult(results);
		199
		200		/// <summary> Initializes a new instance of IndexingResult. </summary>
		201		/// <param name="key"> The key of a document that was in the indexing request. </param>
		202		/// <param name="errorMessage"> The error message explaining why the indexing operation failed for the document
		203		/// <param name="succeeded"> A value indicating whether the indexing operation succeeded for the document identi
		204		/// <param name="status"> The status code of the indexing operation. Possible values include: 200 for a successf
		205		/// <returns> A new IndexingResult instance for mocking. </returns>
		206		public static IndexingResult IndexingResult(
		207		string key,
		208		string errorMessage,
		209		bool succeeded,
		210		int status) =>
	0	211		new IndexingResult(key, errorMessage, succeeded, status);
		212		}
		213		}

C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Models\SearchResult{T}.cs

	#	Line		Line coverage
		1		// Copyright (c) Microsoft Corporation. All rights reserved.
		2		// Licensed under the MIT License.
		3
		4		using System.Collections.Generic;
		5		using System.Diagnostics;
		6		using System.IO;
		7		using System.Text.Json;
		8		using System.Threading;
		9		using System.Threading.Tasks;
		10		using Azure.Core;
		11		#if EXPERIMENTAL_SERIALIZER
		12		using Azure.Core.Serialization;
		13		#endif
		14
		15		#pragma warning disable SA1402 // File may only contain a single type
		16
		17		namespace Azure.Search.Documents.Models
		18		{
		19		// Hide the untyped SearchResult
		20		[CodeGenModel("SearchResult")]
		21		internal partial class SearchResult { }
		22
		23		/// <summary>
		24		/// Contains a document found by a search query, plus associated metadata.
		25		/// </summary>
		26		/// <typeparam name="T">
		27		/// The .NET type that maps to the index schema. Instances of this type can
		28		/// be retrieved as documents from the index.
		29		/// </typeparam>
		30		public class SearchResult<T>
		31		{
		32		/// <summary>
		33		/// The relevance score of the document compared to other documents
		34		/// returned by the query.
		35		/// </summary>
		36		public double? Score { get; internal set; }
		37
		38		/// <summary>
		39		/// Text fragments from the document that indicate the matching search
		40		/// terms, organized by each applicable field; null if hit highlighting
		41		/// was not enabled for the query.
		42		/// </summary>
		43		public IDictionary<string, IList<string>> Highlights { get; internal set; }
		44
		45		/// <summary>
		46		/// The document found by the search query.
		47		/// </summary>
		48		public T Document { get; internal set; }
		49
		50		/// <summary>
		51		/// Initializes a new instance of the SearchResult class.
		52		/// </summary>
		53		internal SearchResult() { }
		54
		55		#pragma warning disable CS1572 // Not all parameters will be used depending on feature flags
		56		/// <summary>
		57		/// Deserialize a SearchResult and its model.
		58		/// </summary>
		59		/// <param name="element">A JSON element.</param>
		60		/// <param name="serializer">
		61		/// Optional serializer that can be used to customize the serialization
		62		/// of strongly typed models.
		63		/// </param>
		64		/// <param name="options">JSON serializer options.</param>
		65		/// <param name="async">Whether to execute sync or async.</param>
		66		/// <param name="cancellationToken">
		67		/// Optional <see cref="CancellationToken"/> to propagate notifications
		68		/// that the operation should be canceled.
		69		/// </param>
		70		/// <returns>Deserialized SearchResults.</returns>
		71		internal static async Task<SearchResult<T>> DeserializeAsync(
		72		JsonElement element,
		73		#if EXPERIMENTAL_SERIALIZER
		74		ObjectSerializer serializer,
		75		#endif
		76		JsonSerializerOptions options,
		77		bool async,
		78		CancellationToken cancellationToken)
		79		#pragma warning restore CS1572
		80		{
		81		Debug.Assert(options != null);
		82		SearchResult<T> result = new SearchResult<T>();
		83		foreach (JsonProperty prop in element.EnumerateObject())
		84		{
		85		if (prop.NameEquals(Constants.SearchScoreKeyJson.EncodedUtf8Bytes) &&
		86		prop.Value.ValueKind != JsonValueKind.Null)
		87		{
		88		result.Score = prop.Value.GetDouble();
		89		}
		90		else if (prop.NameEquals(Constants.SearchHighlightsKeyJson.EncodedUtf8Bytes))
		91		{
		92		result.Highlights = new Dictionary<string, IList<string>>();
		93		foreach (JsonProperty highlight in prop.Value.EnumerateObject())
		94		{
		95		// Add the highlight values
		96		List<string> values = new List<string>();
		97		result.Highlights[highlight.Name] = values;
		98		foreach (JsonElement highlightValue in highlight.Value.EnumerateArray())
		99		{
		100		values.Add(highlightValue.GetString());
		101		}
		102		}
		103		}
		104		}
		105
		106		// Deserialize the model
		107		#if EXPERIMENTAL_SERIALIZER
		108		if (serializer != null)
		109		{
		110		using Stream stream = element.ToStream();
		111		T document = async ?
		112		(T)await serializer.DeserializeAsync(stream, typeof(T), cancellationToken).ConfigureAwait(false) :
		113		(T)serializer.Deserialize(stream, typeof(T), cancellationToken);
		114		result.Document = document;
		115		}
		116		else
		117		{
		118		#endif
		119		T document;
		120		if (async)
		121		{
		122		using Stream stream = element.ToStream();
		123		document = await JsonSerializer.DeserializeAsync<T>(stream, options, cancellationToken).ConfigureAwa
		124		}
		125		else
		126		{
		127		document = JsonSerializer.Deserialize<T>(element.GetRawText(), options);
		128		}
		129		result.Document = document;
		130		#if EXPERIMENTAL_SERIALIZER
		131		}
		132		#endif
		133
		134		return result;
		135		}
		136		}
		137
		138		public static partial class SearchModelFactory
		139		{
		140		/// <summary> Initializes a new instance of SearchResult. </summary>
		141		/// <typeparam name="T">
		142		/// The .NET type that maps to the index schema. Instances of this type can
		143		/// be retrieved as documents from the index.
		144		/// </typeparam>
		145		/// <param name="document">The document found by the search query.</param>
		146		/// <param name="score">
		147		/// The relevance score of the document compared to other documents
		148		/// returned by the query.
		149		/// </param>
		150		/// <param name="highlights">
		151		/// Text fragments from the document that indicate the matching search
		152		/// terms, organized by each applicable field; null if hit highlighting
		153		/// was not enabled for the query.
		154		/// </param>
		155		/// <returns>A new SearchResult instance for mocking.</returns>
		156		public static SearchResult<T> SearchResult<T>(
		157		T document,
		158		double? score,
		159		IDictionary<string, IList<string>> highlights) =>
	0	160		new SearchResult<T>()
	0	161		{
	0	162		Score = score,
	0	163		Highlights = highlights,
	0	164		Document = document };
		165		}
		166		}

C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Models\SearchResults{T}.cs

	#	Line		Line coverage
		1		// Copyright (c) Microsoft Corporation. All rights reserved.
		2		// Licensed under the MIT License.
		3
		4		using System;
		5		using System.Collections.Generic;
		6		using System.Collections.ObjectModel;
		7		using System.Diagnostics;
		8		using System.IO;
		9		using System.Text.Json;
		10		using System.Threading;
		11		using System.Threading.Tasks;
		12		using Azure.Core;
		13		using Azure.Core.Pipeline;
		14		#if EXPERIMENTAL_SERIALIZER
		15		using Azure.Core.Serialization;
		16		#endif
		17
		18		#pragma warning disable SA1402 // File may only contain a single type
		19
		20		namespace Azure.Search.Documents.Models
		21		{
		22		// Hide the untyped SearchDocumentsResult
		23		[CodeGenModel("SearchDocumentsResult")]
		24		internal partial class SearchDocumentsResult { }
		25
		26		/// <summary>
		27		/// Response containing search results from an index.
		28		/// </summary>
		29		public class SearchResults<T>
		30		{
		31		/// <summary>
		32		/// The total count of results found by the search operation, or null
		33		/// if the count was not requested via
		34		/// <see cref="SearchOptions.IncludeTotalCount"/>.  If present, the
		35		/// count may be greater than the number of results in this response.
		36		/// This can happen if you use the <see cref="SearchOptions.Size"/> or
		37		/// <see cref="SearchOptions.Skip"/> parameters, or if Azure Cognitive
		38		/// Search can't return all the requested documents in a single Search
		39		/// response.
		40		/// </summary>
		41		public long? TotalCount { get; internal set; }
		42
		43		/// <summary>
		44		/// A value indicating the percentage of the index that was included in
		45		/// the query, or null if <see cref="SearchOptions.MinimumCoverage"/>
		46		/// was not specified in the request.
		47		/// </summary>
		48		public double? Coverage { get; internal set; }
		49
		50		/// <summary>
		51		/// The facet query results for the search operation, organized as a
		52		/// collection of buckets for each faceted field; null if the query did
		53		/// not include any facet expressions via
		54		/// <see cref="SearchOptions.Facets"/>.
		55		/// </summary>
		56		public IDictionary<string, IList<FacetResult>> Facets { get; internal set; }
		57
		58		/// <summary>
		59		/// Gets the first (server side) page of search result values.
		60		/// </summary>
		61		internal List<SearchResult<T>> Values { get; } = new List<SearchResult<T>>();
		62
		63		/// <summary>
		64		/// Gets or sets the fully constructed URI for the next page of
		65		/// results.
		66		/// </summary>
		67		internal Uri NextUri { get; set; }
		68
		69		/// <summary>
		70		/// Gets or sets the SearchOptions required to fetch the next page of
		71		/// results.
		72		/// </summary>
		73		internal SearchOptions NextOptions { get; set; }
		74
		75		/// <summary>
		76		/// Gets the raw Response that obtained these results from the service.
		77		/// This is only used when paging.
		78		/// </summary>
		79		internal Response RawResponse { get; set; }
		80
		81		/// <summary>
		82		/// The SearchClient used to fetch the next page of results.  This is
		83		/// only used when paging.
		84		/// </summary>
		85		private SearchClient _pagingClient;
		86
		87		/// <summary>
		88		/// Initializes a new instance of the SearchResults class.
		89		/// </summary>
		90		internal SearchResults() { }
		91
		92		/// <summary>
		93		/// Get all of the <see cref="SearchResult{T}"/>s synchronously.
		94		/// </summary>
		95		/// <returns>The search results.</returns>
		96		public Pageable<SearchResult<T>> GetResults() =>
		97		new SearchPageable<T>(this);
		98
		99		/// <summary>
		100		/// Get all of the <see cref="SearchResult{T}"/>s asynchronously.
		101		/// </summary>
		102		/// <returns>The search results.</returns>
		103		public AsyncPageable<SearchResult<T>> GetResultsAsync() =>
		104		new SearchAsyncPageable<T>(this);
		105
		106		/// <summary>
		107		/// Initialize the state needed to allow paging.
		108		/// </summary>
		109		/// <param name="client">
		110		/// The SearchClient to make requests.
		111		/// </param>
		112		/// <param name="rawResponse">
		113		/// The raw response that obtained these results.
		114		/// </param>
		115		internal void ConfigurePaging(SearchClient client, Response rawResponse)
		116		{
		117		Debug.Assert(client != null);
		118		Debug.Assert(rawResponse != null);
		119		_pagingClient = client;
		120		RawResponse = rawResponse;
		121		}
		122
		123		/// <summary>
		124		/// Get the next (server-side) page of results.
		125		/// </summary>
		126		/// <param name="async">
		127		/// Whether to execute synchronously or asynchronously.
		128		/// </param>
		129		/// <param name="cancellationToken">
		130		/// Optional <see cref="CancellationToken"/> to propagate notifications
		131		/// that the operation should be canceled.
		132		/// </param>
		133		/// <returns>The next page of SearchResults.</returns>
		134		internal async Task<SearchResults<T>> GetNextPageAsync(bool async, CancellationToken cancellationToken)
		135		{
		136		SearchResults<T> next = null;
		137		if (_pagingClient != null && NextOptions != null)
		138		{
		139		next = async ?
		140		await _pagingClient.SearchAsync<T>(
		141		NextOptions.SearchText,
		142		NextOptions,
		143		cancellationToken)
		144		.ConfigureAwait(false) :
		145		_pagingClient.Search<T>(
		146		NextOptions.SearchText,
		147		NextOptions,
		148		cancellationToken);
		149		}
		150		return next;
		151		}
		152
		153		#pragma warning disable CS1572 // Not all parameters will be used depending on feature flags
		154		/// <summary>
		155		/// Deserialize the SearchResults.
		156		/// </summary>
		157		/// <param name="json">A JSON stream.</param>
		158		/// <param name="serializer">
		159		/// Optional serializer that can be used to customize the serialization
		160		/// of strongly typed models.
		161		/// </param>
		162		/// <param name="async">Whether to execute sync or async.</param>
		163		/// <param name="cancellationToken">
		164		/// Optional <see cref="CancellationToken"/> to propagate notifications
		165		/// that the operation should be canceled.
		166		/// </param>
		167		/// <returns>Deserialized SearchResults.</returns>
		168		internal static async Task<SearchResults<T>> DeserializeAsync(
		169		Stream json,
		170		#if EXPERIMENTAL_SERIALIZER
		171		ObjectSerializer serializer,
		172		#endif
		173		bool async,
		174		CancellationToken cancellationToken)
		175		#pragma warning restore CS1572
		176		{
		177		// Parse the JSON
		178		using JsonDocument doc = async ?
		179		await JsonDocument.ParseAsync(json, cancellationToken: cancellationToken).ConfigureAwait(false) :
		180		JsonDocument.Parse(json);
		181
		182		JsonSerializerOptions defaultSerializerOptions = JsonSerialization.SerializerOptions;
		183
		184		SearchResults<T> results = new SearchResults<T>();
		185		foreach (JsonProperty prop in doc.RootElement.EnumerateObject())
		186		{
		187		if (prop.NameEquals(Constants.ODataCountKeyJson.EncodedUtf8Bytes) &&
		188		prop.Value.ValueKind != JsonValueKind.Null)
		189		{
		190		results.TotalCount = prop.Value.GetInt64();
		191		}
		192		else if (prop.NameEquals(Constants.SearchCoverageKeyJson.EncodedUtf8Bytes) &&
		193		prop.Value.ValueKind != JsonValueKind.Null)
		194		{
		195		results.Coverage = prop.Value.GetDouble();
		196		}
		197		else if (prop.NameEquals(Constants.SearchFacetsKeyJson.EncodedUtf8Bytes))
		198		{
		199		results.Facets = new Dictionary<string, IList<FacetResult>>();
		200		foreach (JsonProperty facetObject in prop.Value.EnumerateObject())
		201		{
		202		// Get the values of the facet
		203		List<FacetResult> facets = new List<FacetResult>();
		204		foreach (JsonElement facetValue in facetObject.Value.EnumerateArray())
		205		{
		206		Dictionary<string, object> facetValues = new Dictionary<string, object>();
		207		long? facetCount = null;
		208		foreach (JsonProperty facetProperty in facetValue.EnumerateObject())
		209		{
		210		if (facetProperty.NameEquals(Constants.CountKeyJson.EncodedUtf8Bytes))
		211		{
		212		if (facetProperty.Value.ValueKind != JsonValueKind.Null)
		213		{
		214		facetCount = facetProperty.Value.GetInt64();
		215		}
		216		}
		217		else
		218		{
		219		object value = facetProperty.Value.GetSearchObject();
		220		facetValues[facetProperty.Name] = value;
		221		}
		222		}
		223		facets.Add(new FacetResult(facetCount, facetValues));
		224		}
		225		// Add the facet to the results
		226		results.Facets[facetObject.Name] = facets;
		227		}
		228		}
		229		else if (prop.NameEquals(Constants.ODataNextLinkKeyJson.EncodedUtf8Bytes))
		230		{
		231		results.NextUri = new Uri(prop.Value.GetString());
		232		}
		233		else if (prop.NameEquals(Constants.SearchNextPageKeyJson.EncodedUtf8Bytes))
		234		{
		235		results.NextOptions = SearchOptions.DeserializeSearchOptions(prop.Value);
		236		}
		237		else if (prop.NameEquals(Constants.ValueKeyJson.EncodedUtf8Bytes))
		238		{
		239		foreach (JsonElement element in prop.Value.EnumerateArray())
		240		{
		241		SearchResult<T> result = await SearchResult<T>.DeserializeAsync(
		242		element,
		243		#if EXPERIMENTAL_SERIALIZER
		244		serializer,
		245		#endif
		246		defaultSerializerOptions,
		247		async,
		248		cancellationToken)
		249		.ConfigureAwait(false);
		250		results.Values.Add(result);
		251		}
		252		}
		253		}
		254		return results;
		255		}
		256		}
		257
		258		/// <summary>
		259		/// A page of <see cref="SearchResult{T}"/>s returned from
		260		/// <see cref="SearchResults{T}.GetResultsAsync"/>'s
		261		/// <see cref="AsyncPageable{T}.AsPages(string, int?)"/> method.
		262		/// </summary>
		263		/// <typeparam name="T">
		264		/// The .NET type that maps to the index schema. Instances of this type can
		265		/// be retrieved as documents from the index.
		266		/// </typeparam>
		267		public class SearchResultsPage<T> : Page<SearchResult<T>>
		268		{
		269		private SearchResults<T> _results;
		270		private IReadOnlyList<SearchResult<T>> _values;
		271
		272		internal SearchResultsPage(SearchResults<T> results)
		273		{
		274		Debug.Assert(results != null);
		275		_results = results;
		276		}
		277
		278		/// <summary>
		279		/// The total count of results found by the search operation, or null
		280		/// if the count was not requested via
		281		/// <see cref="SearchOptions.IncludeTotalCount"/>.  If present, the
		282		/// count may be greater than the number of results in this response.
		283		/// This can happen if you use the <see cref="SearchOptions.Size"/> or
		284		/// <see cref="SearchOptions.Skip"/> parameters, or if Azure Cognitive
		285		/// Search can't return all the requested documents in a single Search
		286		/// response.
		287		/// </summary>
		288		public long? TotalCount => _results.TotalCount;
		289
		290		/// <summary>
		291		/// A value indicating the percentage of the index that was included in
		292		/// the query, or null if <see cref="SearchOptions.MinimumCoverage"/>
		293		/// was not specified in the request.
		294		/// </summary>
		295		public double? Coverage => _results.Coverage;
		296
		297		/// <summary>
		298		/// The facet query results for the search operation, organized as a
		299		/// collection of buckets for each faceted field; null if the query did
		300		/// not include any facet expressions via
		301		/// <see cref="SearchOptions.Facets"/>.
		302		/// </summary>
		303		public IDictionary<string, IList<FacetResult>> Facets => _results.Facets;
		304
		305		/// <inheritdoc />
		306		public override IReadOnlyList<SearchResult<T>> Values =>
		307		_values ??= new ReadOnlyCollection<SearchResult<T>>(_results.Values);
		308
		309		/// <inheritdoc />
		310		public override string ContinuationToken =>
		311		SearchContinuationToken.Serialize(_results.NextUri, _results.NextOptions);
		312
		313		/// <inheritdoc />
		314		public override Response GetRawResponse() => _results.RawResponse;
		315		}
		316
		317		/// <summary>
		318		/// <see cref="AsyncPageable{T}"/> of <see cref="SearchResult{T}"/>s
		319		/// returned from <see cref="SearchResults{T}.GetResultsAsync"/> to
		320		/// enumerate all of the search results.
		321		/// </summary>
		322		/// <typeparam name="T">
		323		/// The .NET type that maps to the index schema. Instances of this type can
		324		/// be retrieved as documents from the index.
		325		/// </typeparam>
		326		internal class SearchAsyncPageable<T> : AsyncPageable<SearchResult<T>>
		327		{
		328		private SearchResults<T> _results;
		329		public SearchAsyncPageable(SearchResults<T> results)
		330		{
		331		Debug.Assert(results != null);
		332		_results = results;
		333		}
		334
		335		/// <inheritdoc />
		336		public override async IAsyncEnumerable<Page<SearchResult<T>>> AsPages(string continuationToken = default, int? p
		337		{
		338		// The first page of our results is always provided so we can
		339		// ignore the continuation token.  Users can only provide a token
		340		// directly to the Search method.
		341		Debug.Assert(continuationToken == null);
		342
		343		SearchResults<T> initial = _results;
		344		for (SearchResults<T> results = initial;
		345		results != null;
		346		results = await results.GetNextPageAsync(async: true, CancellationToken).ConfigureAwait(false))
		347		{
		348		yield return new SearchResultsPage<T>(results);
		349		}
		350		}
		351		}
		352
		353		/// <summary>
		354		/// <see cref="Pageable{T}"/> of <see cref="SearchResult{T}"/>s returned
		355		/// from <see cref="SearchResults{T}.GetResults"/> to enumerate all of the
		356		/// search results.
		357		/// </summary>
		358		/// <typeparam name="T">
		359		/// The .NET type that maps to the index schema. Instances of this type can
		360		/// be retrieved as documents from the index.
		361		/// </typeparam>
		362		internal class SearchPageable<T> : Pageable<SearchResult<T>>
		363		{
		364		private SearchResults<T> _results;
		365		public SearchPageable(SearchResults<T> results)
		366		{
		367		Debug.Assert(results != null);
		368		_results = results;
		369		}
		370
		371		/// <inheritdoc />
		372		public override IEnumerable<Page<SearchResult<T>>> AsPages(string continuationToken = default, int? pageSizeHint
		373		{
		374		// The first page of our results is always provided so we can
		375		// ignore the continuation token.  Users can only provide a token
		376		// directly to the Search method.
		377		Debug.Assert(continuationToken == null);
		378
		379		SearchResults<T> initial = _results;
		380		for (SearchResults<T> results = initial;
		381		results != null;
		382		results = results.GetNextPageAsync(async: false, CancellationToken).EnsureCompleted())
		383		{
		384		yield return new SearchResultsPage<T>(results);
		385		}
		386		}
		387		}
		388
		389		public static partial class SearchModelFactory
		390		{
		391		/// <summary> Initializes a new instance of SearchResults. </summary>
		392		/// <typeparam name="T">
		393		/// The .NET type that maps to the index schema. Instances of this type can
		394		/// be retrieved as documents from the index.
		395		/// </typeparam>
		396		/// <param name="values">The search result values.</param>
		397		/// <param name="totalCount">The total count of results found by the search operation.</param>
		398		/// <param name="facets">The facet query results for the search operation.</param>
		399		/// <param name="coverage">A value indicating the percentage of the index that was included in the query</param>
		400		/// <param name="rawResponse">The raw Response that obtained these results from the service.</param>
		401		/// <returns>A new SearchResults instance for mocking.</returns>
		402		public static SearchResults<T> SearchResults<T>(
		403		IEnumerable<SearchResult<T>> values,
		404		long? totalCount,
		405		IDictionary<string, IList<FacetResult>> facets,
		406		double? coverage,
		407		Response rawResponse)
		408		{
	0	409		var results = new SearchResults<T>()
	0	410		{
	0	411		TotalCount = totalCount,
	0	412		Coverage = coverage,
	0	413		Facets = facets,
	0	414		RawResponse = rawResponse
	0	415		};
	0	416		results.Values.AddRange(values);
	0	417		return results;
		418		}
		419
		420		/// <summary> Initializes a new instance of SearchResultsPage. </summary>
		421		/// <typeparam name="T">
		422		/// The .NET type that maps to the index schema. Instances of this type can
		423		/// be retrieved as documents from the index.
		424		/// </typeparam>
		425		/// <param name="results">The search results for this page.</param>
		426		/// <returns>A new SearchResultsPage instance for mocking.</returns>
		427		public static SearchResultsPage<T> SearchResultsPage<T>(
		428		SearchResults<T> results) =>
	0	429		new SearchResultsPage<T>(results);
		430		}
		431		}

C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Models\SearchSuggestion{T}.cs

	#	Line		Line coverage
		1		// Copyright (c) Microsoft Corporation. All rights reserved.
		2		// Licensed under the MIT License.
		3
		4		using System.Diagnostics;
		5		using System.IO;
		6		using System.Text.Json;
		7		using System.Threading;
		8		using System.Threading.Tasks;
		9		using Azure.Core;
		10		#if EXPERIMENTAL_SERIALIZER
		11		using Azure.Core.Serialization;
		12		#endif
		13
		14		#pragma warning disable SA1402 // File may only contain a single type
		15
		16		namespace Azure.Search.Documents.Models
		17		{
		18		// Hide the untyped SuggestResult
		19		[CodeGenModel("SuggestResult")]
		20		internal partial class SuggestResult { }
		21
		22		/// <summary>
		23		/// A result containing a document found by a suggestion query, plus
		24		/// associated metadata.
		25		/// </summary>
		26		/// <typeparam name="T">
		27		/// The .NET type that maps to the index schema. Instances of this type can
		28		/// be retrieved as documents from the index.
		29		/// </typeparam>
		30		public class SearchSuggestion<T>
		31		{
		32		/// <summary>
		33		/// The text of the suggestion result.
		34		/// </summary>
		35		public string Text { get; internal set; }
		36
		37		/// <summary>
		38		/// The document being suggested.
		39		/// </summary>
		40		public T Document { get; internal set; }
		41
		42		/// <summary>
		43		/// Initializes a new instance of the SearchSuggestion class.
		44		/// </summary>
		45		internal SearchSuggestion() { }
		46
		47		#pragma warning disable CS1572 // Not all parameters will be used depending on feature flags
		48		/// <summary>
		49		/// Deserialize a SearchSuggestion and its model.
		50		/// </summary>
		51		/// <param name="element">A JSON element.</param>
		52		/// <param name="serializer">
		53		/// Optional serializer that can be used to customize the serialization
		54		/// of strongly typed models.
		55		/// </param>
		56		/// <param name="options">JSON serializer options.</param>
		57		/// <param name="async">Whether to execute sync or async.</param>
		58		/// <param name="cancellationToken">
		59		/// Optional <see cref="CancellationToken"/> to propagate notifications
		60		/// that the operation should be canceled.
		61		/// </param>
		62		/// <returns>Deserialized SearchSuggestion.</returns>
		63		internal static async Task<SearchSuggestion<T>> DeserializeAsync(
		64		JsonElement element,
		65		#if EXPERIMENTAL_SERIALIZER
		66		ObjectSerializer serializer,
		67		#endif
		68		JsonSerializerOptions options,
		69		bool async,
		70		CancellationToken cancellationToken)
		71		#pragma warning restore CS1572
		72		{
		73		Debug.Assert(options != null);
		74
		75		SearchSuggestion<T> suggestion = new SearchSuggestion<T>();
		76		foreach (JsonProperty prop in element.EnumerateObject())
		77		{
		78		if (prop.NameEquals(Constants.SearchTextKeyJson.EncodedUtf8Bytes))
		79		{
		80		suggestion.Text = prop.Value.GetString();
		81		break; // We only have one non-model property
		82		}
		83		}
		84
		85		// Deserialize the model
		86		#if EXPERIMENTAL_SERIALIZER
		87		if (serializer != null)
		88		{
		89		using Stream stream = element.ToStream();
		90		T document = async ?
		91		(T)await serializer.DeserializeAsync(stream, typeof(T), cancellationToken).ConfigureAwait(false) :
		92		(T)serializer.Deserialize(stream, typeof(T), cancellationToken);
		93		suggestion.Document = document;
		94		}
		95		else
		96		{
		97		#endif
		98		T document;
		99		if (async)
		100		{
		101		using Stream stream = element.ToStream();
		102		document = await JsonSerializer.DeserializeAsync<T>(stream, options, cancellationToken).ConfigureAwa
		103		}
		104		else
		105		{
		106		document = JsonSerializer.Deserialize<T>(element.GetRawText(), options);
		107		}
		108		suggestion.Document = document;
		109		#if EXPERIMENTAL_SERIALIZER
		110		}
		111		#endif
		112
		113		return suggestion;
		114		}
		115		}
		116
		117		public static partial class SearchModelFactory
		118		{
		119		/// <summary> Initializes a new instance of SearchSuggestion. </summary>
		120		/// <typeparam name="T">
		121		/// The .NET type that maps to the index schema. Instances of this type can
		122		/// be retrieved as documents from the index.
		123		/// </typeparam>
		124		/// <param name="document">The document being suggested.</param>
		125		/// <param name="text">The text of the suggestion result.</param>
		126		/// <returns>A new SuggestResults instance for mocking.</returns>
		127		public static SearchSuggestion<T> SearchSuggestion<T>(
		128		T document,
		129		string text) =>
	0	130		new SearchSuggestion<T>() { Document = document, Text = text };
		131		}
		132		}

C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Models\SuggestResults{T}.cs

	#	Line		Line coverage
		1		// Copyright (c) Microsoft Corporation. All rights reserved.
		2		// Licensed under the MIT License.
		3
		4		using System.Collections.Generic;
		5		using System.Collections.ObjectModel;
		6		using System.IO;
		7		using System.Text.Json;
		8		using System.Threading;
		9		using System.Threading.Tasks;
		10		using Azure.Core;
		11		#if EXPERIMENTAL_SERIALIZER
		12		using Azure.Core.Serialization;
		13		#endif
		14
		15		#pragma warning disable SA1402 // File may only contain a single type
		16
		17		namespace Azure.Search.Documents.Models
		18		{
		19		// Hide the untyped SuggestDocumentsResult
		20		[CodeGenModel("SuggestDocumentsResult")]
		21		internal partial class SuggestDocumentsResult { }
		22
		23		/// <summary>
		24		/// Response containing suggestion query results from an index.
		25		/// </summary>
		26		/// <typeparam name="T">
		27		/// The .NET type that maps to the index schema. Instances of this type can
		28		/// be retrieved as documents from the index.
		29		/// </typeparam>
		30		public partial class SuggestResults<T>
		31		{
		32		/// <summary>
		33		/// A value indicating the percentage of the index that was included in
		34		/// the query, or null if minimumCoverage was not set in the request.
		35		/// </summary>
		36		public double? Coverage { get; internal set; }
		37
		38		/// <summary>
		39		/// The sequence of suggestions returned by the query.
		40		/// </summary>
		41		public IReadOnlyList<SearchSuggestion<T>> Results { get; internal set; }
		42
		43		/// <summary>
		44		/// Initializes a new instance of the SuggestResults class.
		45		/// </summary>
		46		internal SuggestResults() { }
		47
		48		#pragma warning disable CS1572 // Not all parameters will be used depending on feature flags
		49		/// <summary>
		50		/// Deserialize the SuggestResults.
		51		/// </summary>
		52		/// <param name="json">A JSON stream.</param>
		53		/// <param name="serializer">
		54		/// Optional serializer that can be used to customize the serialization
		55		/// of strongly typed models.
		56		/// </param>
		57		/// <param name="async">Whether to execute sync or async.</param>
		58		/// <param name="cancellationToken">
		59		/// Optional <see cref="CancellationToken"/> to propagate notifications
		60		/// that the operation should be canceled.
		61		/// </param>
		62		/// <returns>Deserialized SuggestResults.</returns>
		63		internal static async Task<SuggestResults<T>> DeserializeAsync(
		64		Stream json,
		65		#if EXPERIMENTAL_SERIALIZER
		66		ObjectSerializer serializer,
		67		#endif
		68		bool async,
		69		CancellationToken cancellationToken)
		70		#pragma warning restore CS1572
		71		{
		72		// Parse the JSON
		73		using JsonDocument doc = async ?
		74		await JsonDocument.ParseAsync(json, cancellationToken: cancellationToken).ConfigureAwait(false) :
		75		JsonDocument.Parse(json);
		76
		77		JsonSerializerOptions defaultSerializerOptions = JsonSerialization.SerializerOptions;
		78
		79		SuggestResults<T> suggestions = new SuggestResults<T>();
		80		foreach (JsonProperty prop in doc.RootElement.EnumerateObject())
		81		{
		82		if (prop.NameEquals(Constants.SearchCoverageKeyJson.EncodedUtf8Bytes) &&
		83		prop.Value.ValueKind != JsonValueKind.Null)
		84		{
		85		suggestions.Coverage = prop.Value.GetDouble();
		86		}
		87		else if (prop.NameEquals(Constants.ValueKeyJson.EncodedUtf8Bytes))
		88		{
		89		List<SearchSuggestion<T>> results = new List<SearchSuggestion<T>>();
		90		foreach (JsonElement element in prop.Value.EnumerateArray())
		91		{
		92		SearchSuggestion<T> suggestion = await SearchSuggestion<T>.DeserializeAsync(
		93		element,
		94		#if EXPERIMENTAL_SERIALIZER
		95		serializer,
		96		#endif
		97		defaultSerializerOptions,
		98		async,
		99		cancellationToken)
		100		.ConfigureAwait(false);
		101		results.Add(suggestion);
		102		}
		103		suggestions.Results = new ReadOnlyCollection<SearchSuggestion<T>>(results);
		104		}
		105		}
		106		return suggestions;
		107		}
		108		}
		109
		110		public static partial class SearchModelFactory
		111		{
		112		/// <summary> Initializes a new instance of SearchResult. </summary>
		113		/// <typeparam name="T">
		114		/// The .NET type that maps to the index schema. Instances of this type
		115		/// can be retrieved as documents from the index.
		116		/// </typeparam>
		117		/// <param name="results">
		118		/// The sequence of suggestions returned by the query.
		119		/// </param>
		120		/// <param name="coverage">
		121		/// A value indicating the percentage of the index that was included in
		122		/// the query, or null if minimumCoverage was not set in the request.
		123		/// </param>
		124		/// <returns>A new SuggestResults instance for mocking.</returns>
		125		public static SuggestResults<T> SuggestResults<T>(
		126		IReadOnlyList<SearchSuggestion<T>> results,
		127		double? coverage) =>
	0	128		new SuggestResults<T>() { Coverage = coverage, Results = results };
		129		}
		130		}