/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (AgreementId != null)
{
hashCode = hashCode * 59 + AgreementId.GetHashCode();
}
if (RequestorId != null)
{
hashCode = hashCode * 59 + RequestorId.GetHashCode();
}
if (Demand != null)
{
hashCode = hashCode * 59 + Demand.GetHashCode();
}
if (ProviderId != null)
{
hashCode = hashCode * 59 + ProviderId.GetHashCode();
}
if (Offer != null)
{
hashCode = hashCode * 59 + Offer.GetHashCode();
}
return(hashCode);
}
}
/// <summary>
/// Return a XML representation of this object.
/// </summary>
/// <param name="CustomAuthorizeRemoteStartRequestSerializer">A delegate to customize the serialization of AuthorizeRemoteStart requests.</param>
/// <param name="CustomIdentificationSerializer">A delegate to serialize custom Identification XML elements.</param>
public XElement ToXML(CustomXMLSerializerDelegate <AuthorizeRemoteStartRequest> CustomAuthorizeRemoteStartRequestSerializer = null,
CustomXMLSerializerDelegate <Identification> CustomIdentificationSerializer = null)
{
var XML = new XElement(OICPNS.Authorization + "eRoamingAuthorizeRemoteStart",
SessionId.HasValue
? new XElement(OICPNS.Authorization + "SessionID", SessionId.ToString())
: null,
CPOPartnerSessionId.HasValue
? new XElement(OICPNS.Authorization + "CPOPartnerSessionID", CPOPartnerSessionId.ToString())
: null,
EMPPartnerSessionId.HasValue
? new XElement(OICPNS.Authorization + "EMPPartnerSessionID", EMPPartnerSessionId.ToString())
: null,
new XElement(OICPNS.Authorization + "ProviderID", ProviderId.ToString()),
new XElement(OICPNS.Authorization + "EvseID", EVSEId.ToString()),
Identification.ToXML(CustomIdentificationSerializer: CustomIdentificationSerializer),
PartnerProductId.HasValue
? new XElement(OICPNS.Authorization + "PartnerProductID", PartnerProductId.ToString())
: null
);
return(CustomAuthorizeRemoteStartRequestSerializer != null
? CustomAuthorizeRemoteStartRequestSerializer(this, XML)
: XML);
}
/// <summary>
/// Return the HashCode of this object.
/// </summary>
/// <returns>The HashCode of this object.</returns>
public override Int32 GetHashCode()
{
unchecked
{
return(ProviderId.GetHashCode() * 17 ^ Suffix.GetHashCode());
}
}
public async Task<AnalysisData> GetDocumentBodyAnalysisDataAsync(
DiagnosticAnalyzer provider, ProviderId providerId, VersionArgument versions, DiagnosticAnalyzerDriver analyzerDriver,
SyntaxNode root, SyntaxNode member, int memberId, bool supportsSemanticInSpan, MemberRangeMap.MemberRanges ranges)
{
try
{
var document = analyzerDriver.Document;
var cancellationToken = analyzerDriver.CancellationToken;
var state = AnalyzersAndState.GetOrCreateDiagnosticState(StateType.Document, providerId, provider, document.Project.Id, document.Project.Language);
var existingData = await state.TryGetExistingDataAsync(document, cancellationToken).ConfigureAwait(false);
ImmutableArray<DiagnosticData> diagnosticData;
if (supportsSemanticInSpan && CanUseDocumentState(existingData, ranges.TextVersion, versions.DataVersion))
{
var memberDxData = await GetSemanticDiagnosticsAsync(providerId, provider, analyzerDriver).ConfigureAwait(false);
diagnosticData = _owner.UpdateDocumentDiagnostics(existingData, ranges.Ranges, memberDxData.AsImmutableOrEmpty(), root.SyntaxTree, member, memberId);
ValidateMemberDiagnostics(providerId, provider, document, root, diagnosticData);
}
else
{
// if we can't re-use existing document state, only option we have is updating whole document state here.
var dx = await GetSemanticDiagnosticsAsync(providerId, provider, analyzerDriver).ConfigureAwait(false);
diagnosticData = dx.AsImmutableOrEmpty();
}
return new AnalysisData(versions.TextVersion, versions.DataVersion, GetExistingItems(existingData), diagnosticData);
}
catch (Exception e) when (FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
/// <summary>
/// Return the HashCode of this object.
/// </summary>
/// <returns>The HashCode of this object.</returns>
public override Int32 GetHashCode()
{
unchecked
{
return(ProviderId.GetHashCode() * 17 ^
EVSEId.GetHashCode() * 13 ^
Identification.GetHashCode() * 11 ^
(SessionId.HasValue
? SessionId.GetHashCode() * 9
: 0) ^
(CPOPartnerSessionId.HasValue
? CPOPartnerSessionId.GetHashCode() * 7
: 0) ^
(EMPPartnerSessionId.HasValue
? EMPPartnerSessionId.GetHashCode() * 5
: 0) ^
(PartnerProductId.HasValue
? PartnerProductId.GetHashCode() * 3
: 0) ^
(Duration.HasValue
? Duration.GetHashCode()
: 0));
}
}
public override int GetHashCode()
{
return(PersonId.GetHashCode() ^
ConceptId.GetHashCode() ^
TypeConceptId.GetHashCode() ^
(SourceValue != null ? SourceValue.GetHashCode() : 0) ^
(StopReason != null ? StopReason.GetHashCode() : 0) ^
Refills.GetHashCode() ^
VisitOccurrenceId.GetHashCode() ^
Quantity.GetHashCode() ^
DaysSupply.GetHashCode() ^
RouteConceptId.GetHashCode() ^
EffectiveDrugDose.GetHashCode() ^
DoseUnitConceptId.GetHashCode() ^
SourceConceptId.GetHashCode() ^
(Sig != null ? Sig.GetHashCode() : 0) ^
(LotNumber != null ? LotNumber.GetHashCode() : 0) ^
(RouteSourceValue != null ? RouteSourceValue.GetHashCode() : 0) ^
(DoseUnitSourceValue != null ? DoseUnitSourceValue.GetHashCode() : 0) ^
ProviderId.GetHashCode() ^
(StartDate.GetHashCode()) ^
(EndDate.GetHashCode()) ^
(VerbatimEndDate.GetHashCode()) ^
(StartTime != null ? StartTime.GetHashCode() : 0) ^
(EndTime != null ? EndTime.GetHashCode() : 0));
}
/// <summary>
/// Compares two authorize remote reservation start requests for equality.
/// </summary>
/// <param name="AuthorizeRemoteReservationStartRequest">An authorize remote reservation start request to compare with.</param>
/// <returns>True if both match; False otherwise.</returns>
public override Boolean Equals(AuthorizeRemoteReservationStartRequest AuthorizeRemoteReservationStartRequest)
{
if (AuthorizeRemoteReservationStartRequest is null)
{
return(false);
}
return(ProviderId.Equals(AuthorizeRemoteReservationStartRequest.ProviderId) &&
EVSEId.Equals(AuthorizeRemoteReservationStartRequest.EVSEId) &&
Identification.Equals(AuthorizeRemoteReservationStartRequest.Identification) &&
((!SessionId.HasValue && !AuthorizeRemoteReservationStartRequest.SessionId.HasValue) ||
(SessionId.HasValue && AuthorizeRemoteReservationStartRequest.SessionId.HasValue && SessionId.Value.Equals(AuthorizeRemoteReservationStartRequest.SessionId.Value))) &&
((!CPOPartnerSessionId.HasValue && !AuthorizeRemoteReservationStartRequest.CPOPartnerSessionId.HasValue) ||
(CPOPartnerSessionId.HasValue && AuthorizeRemoteReservationStartRequest.CPOPartnerSessionId.HasValue && CPOPartnerSessionId.Value.Equals(AuthorizeRemoteReservationStartRequest.CPOPartnerSessionId.Value))) &&
((!EMPPartnerSessionId.HasValue && !AuthorizeRemoteReservationStartRequest.EMPPartnerSessionId.HasValue) ||
(EMPPartnerSessionId.HasValue && AuthorizeRemoteReservationStartRequest.EMPPartnerSessionId.HasValue && EMPPartnerSessionId.Value.Equals(AuthorizeRemoteReservationStartRequest.EMPPartnerSessionId.Value))) &&
((!PartnerProductId.HasValue && !AuthorizeRemoteReservationStartRequest.PartnerProductId.HasValue) ||
(PartnerProductId.HasValue && AuthorizeRemoteReservationStartRequest.PartnerProductId.HasValue && PartnerProductId.Value.Equals(AuthorizeRemoteReservationStartRequest.PartnerProductId.Value))) &&
((!Duration.HasValue && !AuthorizeRemoteReservationStartRequest.Duration.HasValue) ||
(Duration.HasValue && AuthorizeRemoteReservationStartRequest.Duration.HasValue && Duration.Value.Equals(AuthorizeRemoteReservationStartRequest.Duration.Value))));
}
private void DrawProviderBox(string field, ProviderId provider)
{
bool isEditorDefault = _editorProvider.enumValueIndex == (int)provider;
bool isRuntimeDefault = _runtimeProvider.enumValueIndex == (int)provider;
if (isEditorDefault || isRuntimeDefault)
{
GUILayoutTools.LineSeparator();
StringBuilder titleBuilder = new StringBuilder();
titleBuilder.Append(Enum.GetName(typeof(ProviderId), provider));
if (isEditorDefault)
{
titleBuilder.Append(TITLE_SEPARATOR);
titleBuilder.Append(EDITOR_DEFAULT_TITLE);
}
if (isRuntimeDefault)
{
titleBuilder.Append(TITLE_SEPARATOR);
titleBuilder.Append(RUNTIME_DEFAULT_TITLE);
}
EditorGUILayout.LabelField(titleBuilder.ToString(), WearableEditorConstants.EMPTY_LAYOUT_OPTIONS);
EditorGUILayout.PropertyField(serializedObject.FindProperty(field), WearableEditorConstants.EMPTY_LAYOUT_OPTIONS);
}
}
private void DrawProviderBox(string field, ProviderId provider)
{
bool isEditorDefault = _editorProvider.enumValueIndex == (int)provider;
bool isRuntimeDefault = _runtimeProvider.enumValueIndex == (int)provider;
if (isEditorDefault || isRuntimeDefault)
{
GUILayout.Box(String.Empty, GUILayout.ExpandWidth(true), GUILayout.Height(1));
StringBuilder titleBuilder = new StringBuilder();
titleBuilder.Append(Enum.GetName(typeof(ProviderId), provider));
if (isEditorDefault)
{
titleBuilder.Append(TitleSeparator);
titleBuilder.Append(EditorDefaultTitle);
}
if (isRuntimeDefault)
{
titleBuilder.Append(TitleSeparator);
titleBuilder.Append(RuntimeDefaultTitle);
}
EditorGUILayout.LabelField(titleBuilder.ToString(), WearableConstants.EmptyLayoutOptions);
EditorGUILayout.PropertyField(serializedObject.FindProperty(field), WearableConstants.EmptyLayoutOptions);
}
}
/// <summary>
/// Return a JSON-representation of this object.
/// </summary>
/// <param name="CustomAuthorizeRemoteReservationStopRequestSerializer">A delegate to customize the serialization of AuthorizeRemoteReservationStopRequest responses.</param>
public JObject ToJSON(CustomJObjectSerializerDelegate <AuthorizeRemoteReservationStopRequest> CustomAuthorizeRemoteReservationStopRequestSerializer = null)
{
var JSON = JSONObject.Create(
new JProperty("ProviderID", ProviderId.ToString()),
new JProperty("EvseID", EVSEId.ToString()),
new JProperty("SessionID", SessionId.ToString()),
CPOPartnerSessionId.HasValue
? new JProperty("CPOPartnerSessionID", CPOPartnerSessionId.Value.ToString())
: null,
EMPPartnerSessionId.HasValue
? new JProperty("EMPPartnerSessionID", EMPPartnerSessionId.Value.ToString())
: null,
CustomData != null
? new JProperty("CustomData", CustomData)
: null
);
return(CustomAuthorizeRemoteReservationStopRequestSerializer != null
? CustomAuthorizeRemoteReservationStopRequestSerializer(this, JSON)
: JSON);
}
public DiagnosticState GetDiagnosticState(StateType stateType, ProviderId providerId)
{
Contract.ThrowIfFalse(providerId >= _startAnalyzerId);
Contract.ThrowIfFalse(providerId < _startAnalyzerId + this.AnalyzerCount);
return(_diagnosticStateMaps[(int)stateType, providerId - _startAnalyzerId]);
}
public async Task <AnalysisData> GetProjectAnalysisDataAsync(
DiagnosticAnalyzer provider, ProviderId providerId, VersionArgument versions, DiagnosticAnalyzerDriver analyzerDriver)
{
try
{
var project = analyzerDriver.Project;
var cancellationToken = analyzerDriver.CancellationToken;
var state = AnalyzersAndState.GetOrCreateDiagnosticState(StateType.Project, providerId, provider, project.Id, project.Language);
var existingData = await state.TryGetExistingDataAsync(project, cancellationToken).ConfigureAwait(false);
if (CheckSemanticVersions(project, existingData, versions))
{
return(existingData);
}
// TODO: remove ForceAnalyzeAllDocuments at some point
var diagnosticData = await GetProjectDiagnosticsAsync(providerId, provider, analyzerDriver, _owner.ForceAnalyzeAllDocuments).ConfigureAwait(false);
return(new AnalysisData(VersionStamp.Default, versions.DataVersion, GetExistingItems(existingData), diagnosticData.AsImmutableOrEmpty()));
}
catch (Exception e) when(FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("----------- ECM INFO -----------");
sb.Append("Service ID: 0x");
sb.AppendLine(ServiceId.ToString("x4"));
sb.Append("PID: 0x");
sb.AppendLine(Pid.ToString("x4"));
sb.Append("Caid: 0x");
sb.AppendLine(CaId.ToString("x4"));
sb.Append("ProvId: 0x");
sb.AppendLine(ProviderId.ToString("x6"));
sb.Append("Cardsystem: ");
sb.AppendLine(CardSystem);
sb.Append("Reader: ");
sb.AppendLine(ReaderName);
sb.Append("Source: ");
sb.AppendLine(SourceName);
sb.Append("Protocol: ");
sb.AppendLine(ProtocolName);
sb.Append("Hops: ");
sb.AppendLine(HopsCount.ToString());
sb.Append("Time: ");
sb.Append(EcmTime.ToString());
sb.AppendLine("ms");
sb.AppendLine("----------- ECM INFO -----------");
return(sb.ToString());
}
/// <summary>
/// Return a XML representation of this object.
/// </summary>
/// <param name="CustomPullEVSEStatusRequestSerializer">A delegate to serialize custom eRoamingPullEvseStatus XML elements.</param>
public XElement ToXML(CustomXMLSerializerDelegate <PullEVSEStatusRequest> CustomPullEVSEStatusRequestSerializer = null)
{
var XML = new XElement(OICPNS.EVSEStatus + "eRoamingPullEvseStatus",
new XElement(OICPNS.EVSEStatus + "ProviderID", ProviderId.ToString()),
SearchCenter.HasValue && DistanceKM > 0
? new XElement(OICPNS.EVSEStatus + "SearchCenter",
new XElement(OICPNS.CommonTypes + "GeoCoordinates",
new XElement(OICPNS.CommonTypes + "DecimalDegree",
new XElement(OICPNS.CommonTypes + "Longitude", SearchCenter.Value.Longitude.ToString("{0:0.######}").Replace(",", ".")),
new XElement(OICPNS.CommonTypes + "Latitude", SearchCenter.Value.Latitude.ToString("{0:0.######}").Replace(",", "."))
)
),
new XElement(OICPNS.CommonTypes + "Radius", String.Format("{0:0.}", DistanceKM).Replace(",", "."))
)
: null,
EVSEStatusFilter.HasValue
? new XElement(OICPNS.EVSEStatus + "EvseStatus", EVSEStatusFilter.Value)
: null
);
return(CustomPullEVSEStatusRequestSerializer != null
? CustomPullEVSEStatusRequestSerializer(this, XML)
: XML);
}
public async Task <AnalysisData> GetDocumentAnalysisDataAsync(
DiagnosticAnalyzer provider, ProviderId providerId, VersionArgument versions, DiagnosticAnalyzerDriver analyzerDrvier)
{
try
{
var document = analyzerDrvier.Document;
var cancellationToken = analyzerDrvier.CancellationToken;
var state = AnalyzersAndState.GetOrCreateDiagnosticState(StateType.Document, providerId, provider, document.Project.Id, document.Project.Language);
var existingData = await state.TryGetExistingDataAsync(document, cancellationToken).ConfigureAwait(false);
if (CheckSemanticVersions(document, existingData, versions))
{
return(existingData);
}
var diagnosticData = await GetSemanticDiagnosticsAsync(providerId, provider, analyzerDrvier).ConfigureAwait(false);
return(new AnalysisData(versions.TextVersion, versions.DataVersion, GetExistingItems(existingData), diagnosticData.AsImmutableOrEmpty()));
}
catch (Exception e) when(FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
public async Task <AnalysisData> GetDocumentBodyAnalysisDataAsync(
DiagnosticAnalyzer provider, ProviderId providerId, VersionArgument versions, DiagnosticAnalyzerDriver analyzerDriver,
SyntaxNode root, SyntaxNode member, int memberId, bool supportsSemanticInSpan, MemberRangeMap.MemberRanges ranges)
{
try
{
var document = analyzerDriver.Document;
var cancellationToken = analyzerDriver.CancellationToken;
var state = AnalyzersAndState.GetOrCreateDiagnosticState(StateType.Document, providerId, provider, document.Project.Id, document.Project.Language);
var existingData = await state.TryGetExistingDataAsync(document, cancellationToken).ConfigureAwait(false);
ImmutableArray <DiagnosticData> diagnosticData;
if (supportsSemanticInSpan && CanUseDocumentState(existingData, ranges.TextVersion, versions.DataVersion))
{
var memberDxData = await GetSemanticDiagnosticsAsync(providerId, provider, analyzerDriver).ConfigureAwait(false);
diagnosticData = _owner.UpdateDocumentDiagnostics(existingData, ranges.Ranges, memberDxData.AsImmutableOrEmpty(), root.SyntaxTree, member, memberId);
ValidateMemberDiagnostics(providerId, provider, document, root, diagnosticData);
}
else
{
// if we can't re-use existing document state, only option we have is updating whole document state here.
var dx = await GetSemanticDiagnosticsAsync(providerId, provider, analyzerDriver).ConfigureAwait(false);
diagnosticData = dx.AsImmutableOrEmpty();
}
return(new AnalysisData(versions.TextVersion, versions.DataVersion, GetExistingItems(existingData), diagnosticData));
}
catch (Exception e) when(FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
/// <summary>
/// Return the HashCode of this object.
/// </summary>
/// <returns>The HashCode of this object.</returns>
public override Int32 GetHashCode()
{
unchecked
{
return(ProviderId.GetHashCode() * 5 ^
OperatorIds.GetHashCode() * 3);
}
}
private void ValidateMemberDiagnostics(ProviderId providerId, DiagnosticAnalyzer provider, Document document, SyntaxNode root, ImmutableArray <DiagnosticData> diagnostics)
{
#if RANGE
var documentBasedDriver = new DiagnosticAnalyzerDriver(document, root.FullSpan, root, CancellationToken.None);
var expected = GetSemanticDiagnosticsAsync(providerId, provider, documentBasedDriver).WaitAndGetResult(documentBasedDriver.CancellationToken) ?? SpecializedCollections.EmptyEnumerable <DiagnosticData>();
Contract.Requires(diagnostics.SetEquals(expected));
#endif
}
/// <summary>
/// Return the HashCode of this object.
/// </summary>
/// <returns>The HashCode of this object.</returns>
public override Int32 GetHashCode()
{
unchecked
{
return(ProviderId.GetHashCode() * 3 ^
AuthorizationIdentifications.GetHashCode());
}
}
public MemberRanges GetSavedMemberRange(ProviderId providerId, Document document)
{
var data = _map.GetOrAdd(document.Id, s_createMap);
lock (data)
{
return GetSavedMemberRange_NoLock(data, providerId, document);
}
}
/// <summary>
/// Return the HashCode of this object.
/// </summary>
/// <returns>The HashCode of this object.</returns>
public override Int32 GetHashCode()
{
unchecked
{
return(ProviderId.GetHashCode() * 3 ^
EVSEIds.Aggregate(0, (hashCode, evseId) => hashCode ^ evseId.GetHashCode()));
}
}
/// <summary>
/// Return the HashCode of this object.
/// </summary>
/// <returns>The HashCode of this object.</returns>
public override Int32 GetHashCode()
{
unchecked
{
return(ProviderId.GetHashCode() * 3 ^
OperatorIds.Aggregate(0, (hashCode, operatorId) => hashCode ^ operatorId.GetHashCode()));
}
}
public override Dictionary <string, string> ToDictionary()
{
var result = base.ToDictionary();
result.Add("ProviderId", ProviderId.ToString());
return(result);
}
private string GetNameForProvider(ProviderId providerId)
{
var result = Enum.GetName(typeof(ProviderId), providerId);
result = result == null ? string.Empty : result.Nicify();
return(result);
}
public MemberRanges GetSavedMemberRange(ProviderId providerId, Document document)
{
var data = _map.GetOrAdd(document.Id, s_createMap);
lock (data)
{
return(GetSavedMemberRange_NoLock(data, providerId, document));
}
}
private void RaiseDiagnosticsUpdatedIfNeeded(Project project, ProviderId providerId, ImmutableArray <DiagnosticData> existingItems, ImmutableArray <DiagnosticData> newItems)
{
var noItems = existingItems.Length == 0 && newItems.Length == 0;
if (!noItems)
{
RaiseDiagnosticsUpdated(StateType.Project, project.Id, providerId, new SolutionArgument(project), newItems);
}
}
/// <summary>
/// Return the HashCode of this object.
/// </summary>
/// <returns>The HashCode of this object.</returns>
public override Int32 GetHashCode()
{
unchecked
{
return(ProviderAuthenticationData.GetHashCode() * 5 ^
ProviderId.GetHashCode() * 3 ^
OICPAction.GetHashCode());
}
}
/// <summary>
/// Return the HashCode of this object.
/// </summary>
/// <returns>The HashCode of this object.</returns>
public override Int32 GetHashCode()
{
unchecked
{
return(ProviderId.GetHashCode() * 7 ^
From.GetHashCode() * 5 ^
To.GetHashCode());
}
}
public void GetProviderIdsFromMetadataTests(string guidInput, ProviderId expected)
{
var param = guidInput.Split('|', StringSplitOptions.RemoveEmptyEntries);
var result = PlexHelper.GetProviderIdsFromMetadata(param);
Assert.AreEqual(expected.ImdbId, result.ImdbId);
Assert.AreEqual(expected.TheMovieDb, result.TheMovieDb);
Assert.AreEqual(expected.TheTvDb, result.TheTvDb);
}
public void Touch(ProviderId providerId, Document document, VersionStamp version)
{
// only touch and updateMemberRange methods are allowed to update the dictionaries
var data = _map.GetOrAdd(document.Id, s_createMap);
lock (data)
{
Touch_NoLock(data, providerId, document, version);
}
}
private void RaiseDiagnosticsUpdated(
StateType type, object key, ProviderId providerId, SolutionArgument solution, ImmutableArray <DiagnosticData> diagnostics)
{
if (_owner != null)
{
var id = new ArgumentKey(providerId, type, key);
_owner.RaiseDiagnosticsUpdated(this,
new DiagnosticsUpdatedArgs(id, _analyzersAndState.Workspace, solution.Solution, solution.ProjectId, solution.DocumentId, diagnostics));
}
}
private async Task HandleSuppressedAnalyzerAsync(Project project, ProviderId providerId, DiagnosticAnalyzer provider, CancellationToken cancellationToken)
{
var state = _analyzersAndState.GetOrCreateDiagnosticState(StateType.Project, providerId, provider, project.Id, project.Language);
var existingData = await state.TryGetExistingDataAsync(project, cancellationToken).ConfigureAwait(false);
if (existingData != null && existingData.Items.Length > 0)
{
await RemoveCacheDataAsync(project, state, providerId, cancellationToken).ConfigureAwait(false);
}
}
public void Touch(ProviderId providerId, Document document, VersionStamp version)
{
// only touch and updateMemberRange methods are allowed to update the dictionaries
var data = _map.GetOrAdd(document.Id, s_createMap);
lock (data)
{
Touch_NoLock(data, providerId, document, version);
}
}
public void UpdateMemberRange(
ProviderId providerId, Document document, VersionStamp newVersion, int memberId, TextSpan span, MemberRanges oldRanges)
{
// only touch and updateMemberRange methods are allowed to update the dictionaries
var data = _map.GetOrAdd(document.Id, s_createMap);
lock (data)
{
// now update member range map
UpdateMemberRange_NoLock(data, document, newVersion, memberId, span, oldRanges.TextVersion);
// save provider version information
Touch_NoLock(data, providerId, document, newVersion);
ValidateMemberRangeMap(document, newVersion);
}
}
public async Task<AnalysisData> GetDocumentAnalysisDataAsync(
DiagnosticAnalyzer provider, ProviderId providerId, VersionArgument versions, DiagnosticAnalyzerDriver analyzerDrvier)
{
try
{
var document = analyzerDrvier.Document;
var cancellationToken = analyzerDrvier.CancellationToken;
var state = AnalyzersAndState.GetOrCreateDiagnosticState(StateType.Document, providerId, provider, document.Project.Id, document.Project.Language);
var existingData = await state.TryGetExistingDataAsync(document, cancellationToken).ConfigureAwait(false);
if (CheckSemanticVersions(document, existingData, versions))
{
return existingData;
}
var diagnosticData = await GetSemanticDiagnosticsAsync(providerId, provider, analyzerDrvier).ConfigureAwait(false);
return new AnalysisData(versions.TextVersion, versions.DataVersion, GetExistingItems(existingData), diagnosticData.AsImmutableOrEmpty());
}
catch (Exception e) when (FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
private async Task RemoveCacheDataAsync(Project project, DiagnosticState state, ProviderId providerId, CancellationToken cancellationToken)
{
try
{
// remove memory cache
state.Remove(project.Id);
// remove persistent cache
await state.PersistAsync(project, AnalysisData.Empty, cancellationToken).ConfigureAwait(false);
// raise diagnostic updated event
var solutionArgs = new SolutionArgument(project);
RaiseDiagnosticsUpdated(StateType.Project, project.Id, providerId, solutionArgs, ImmutableArray<DiagnosticData>.Empty);
}
catch (Exception e) when (FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
public DiagnosticState GetOrCreateDiagnosticState(StateType stateType, ProviderId providerId, DiagnosticAnalyzer provider)
{
Contract.ThrowIfFalse(providerId >= 0);
Contract.ThrowIfFalse(providerId < this.AnalyzerCount);
return DiagnosticAnalyzersAndStates.GetOrCreateDiagnosticState(_diagnosticStateMaps, stateType, providerId, providerId, provider, _language);
}
public DiagnosticState GetDiagnosticState(StateType stateType, ProviderId providerId)
{
Contract.ThrowIfFalse(providerId >= 0);
Contract.ThrowIfFalse(providerId < this.AnalyzerCount);
return _diagnosticStateMaps[(int)stateType, providerId];
}
private void RaiseDiagnosticsUpdatedIfNeeded(Project project, ProviderId providerId, ImmutableArray<DiagnosticData> existingItems, ImmutableArray<DiagnosticData> newItems)
{
var noItems = existingItems.Length == 0 && newItems.Length == 0;
if (!noItems)
{
RaiseDiagnosticsUpdated(StateType.Project, project.Id, providerId, new SolutionArgument(project), newItems);
}
}
private static async Task<IEnumerable<DiagnosticData>> GetProjectDiagnosticsAsync(ProviderId providerId, DiagnosticAnalyzer provider, DiagnosticAnalyzerDriver userDiagnosticDriver, Action<Project, DiagnosticAnalyzer, CancellationToken> forceAnalyzeAllDocuments)
{
using (Logger.LogBlock(FunctionId.Diagnostics_ProjectDiagnostic, GetProjectLogMessage, userDiagnosticDriver.Project, providerId, userDiagnosticDriver.CancellationToken))
{
try
{
Contract.ThrowIfNull(provider);
var diagnostics = await userDiagnosticDriver.GetProjectDiagnosticsAsync(provider, forceAnalyzeAllDocuments).ConfigureAwait(false);
return GetDiagnosticData(userDiagnosticDriver.Project, diagnostics);
}
catch (Exception e) when (FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
}
public async Task<AnalysisData> GetProjectAnalysisDataAsync(
DiagnosticAnalyzer provider, ProviderId providerId, VersionArgument versions, DiagnosticAnalyzerDriver analyzerDriver)
{
try
{
var project = analyzerDriver.Project;
var cancellationToken = analyzerDriver.CancellationToken;
var state = AnalyzersAndState.GetOrCreateDiagnosticState(StateType.Project, providerId, provider, project.Id, project.Language);
var existingData = await state.TryGetExistingDataAsync(project, cancellationToken).ConfigureAwait(false);
if (CheckSemanticVersions(project, existingData, versions))
{
return existingData;
}
// TODO: remove ForceAnalyzeAllDocuments at some point
var diagnosticData = await GetProjectDiagnosticsAsync(providerId, provider, analyzerDriver, _owner.ForceAnalyzeAllDocuments).ConfigureAwait(false);
return new AnalysisData(VersionStamp.Default, versions.DataVersion, GetExistingItems(existingData), diagnosticData.AsImmutableOrEmpty());
}
catch (Exception e) when (FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
private void ValidateMemberDiagnostics(ProviderId providerId, DiagnosticAnalyzer provider, Document document, SyntaxNode root, ImmutableArray<DiagnosticData> diagnostics)
{
#if RANGE
var documentBasedDriver = new DiagnosticAnalyzerDriver(document, root.FullSpan, root, CancellationToken.None);
var expected = GetSemanticDiagnosticsAsync(providerId, provider, documentBasedDriver).WaitAndGetResult(documentBasedDriver.CancellationToken) ?? SpecializedCollections.EmptyEnumerable<DiagnosticData>();
Contract.Requires(diagnostics.SetEquals(expected));
#endif
}
private async Task<bool> TryGetLatestDiagnosticsAsync(
DiagnosticAnalyzer provider, ProviderId providerId,
StateType stateType, Document document, TextSpan range, SyntaxNode root,
List<DiagnosticData> diagnostics, bool requireUpToDateDocumentDiagnostic,
Func<VersionStamp, VersionStamp, bool> versionCheck,
Func<ProviderId, DiagnosticAnalyzer, DiagnosticAnalyzerDriver, Task<IEnumerable<DiagnosticData>>> getDiagnostics,
bool supportsSemanticInSpan,
DiagnosticAnalyzerDriver userDiagnosticDriver,
CancellationToken cancellationToken)
{
try
{
var shouldInclude = (Func<DiagnosticData, bool>)(d => range.IntersectsWith(d.TextSpan));
// make sure we get state even when none of our analyzer has ran yet.
// but this shouldn't create analyzer that doesnt belong to this project (language)
var state = _analyzersAndState.GetOrCreateDiagnosticState(stateType, providerId, provider, document.Project.Id, document.Project.Language);
if (state == null)
{
if (!requireUpToDateDocumentDiagnostic)
{
// the provider never ran yet.
return true;
}
}
else
{
// see whether we can use existing info
var existingData = await state.TryGetExistingDataAsync(document, cancellationToken).ConfigureAwait(false);
if (existingData != null && versionCheck(existingData.TextVersion, existingData.DataVersion))
{
if (existingData.Items == null)
{
return true;
}
diagnostics.AddRange(existingData.Items.Where(shouldInclude));
return true;
}
}
// check whether we want up-to-date document wide diagnostics
if (stateType == StateType.Document && !supportsSemanticInSpan && !requireUpToDateDocumentDiagnostic)
{
return false;
}
var dx = await getDiagnostics(providerId, provider, userDiagnosticDriver).ConfigureAwait(false);
if (dx != null)
{
// no state yet
diagnostics.AddRange(dx.Where(shouldInclude));
}
return true;
}
catch (Exception e) when (FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
public DiagnosticState GetDiagnosticState(StateType stateType, ProviderId providerId, string language)
{
var analyzersAndStates = this.GetOrCreatePerLanguageAnalyzersAndStates(language);
return analyzersAndStates.GetDiagnosticState(stateType, providerId);
}
private void RaiseDiagnosticsUpdated(
StateType type, object key, ProviderId providerId, SolutionArgument solution, ImmutableArray<DiagnosticData> diagnostics)
{
if (_owner != null)
{
var id = new ArgumentKey(providerId, type, key);
_owner.RaiseDiagnosticsUpdated(this,
new DiagnosticsUpdatedArgs(id, _analyzersAndState.Workspace, solution.Solution, solution.ProjectId, solution.DocumentId, diagnostics));
}
}
protected abstract Task<AnalysisData> GetSpecificDiagnosticsAsync(Solution solution, DiagnosticAnalyzer provider, ProviderId providerId, StateType stateType, VersionArgument versions, DiagnosticAnalyzerDriver analyzerDriver);
private async Task RemoveCacheDataAsync(Document document, DiagnosticState state, ProviderId providerId, StateType type, CancellationToken cancellationToken)
{
try
{
// remove memory cache
state.Remove(document.Id);
// remove persistent cache
await state.PersistAsync(document, AnalysisData.Empty, cancellationToken).ConfigureAwait(false);
// raise diagnostic updated event
var documentId = type == StateType.Project ? null : document.Id;
var projectId = document.Project.Id;
var key = documentId ?? (object)projectId;
var solutionArgs = new SolutionArgument(document.Project.Solution, projectId, documentId);
RaiseDiagnosticsUpdated(type, key, providerId, solutionArgs, ImmutableArray<DiagnosticData>.Empty);
}
catch (Exception e) when (FatalError.ReportUnlessCanceled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
public DiagnosticState GetDiagnosticState(StateType stateType, ProviderId providerId, ProjectId projectId, string language)
{
Contract.ThrowIfFalse(providerId >= 0);
var sharedAnalyzersCount = _sharedAnalyzersAndStates.GetAnalyzerCount(language);
if (providerId < sharedAnalyzersCount)
{
return _sharedAnalyzersAndStates.GetDiagnosticState(stateType, providerId, language);
}
ProjectAnalyzersAndStates projectAnalyzersAndStates;
if (!_projectAnalyzersAndStatesMap.TryGetValue(projectId, out projectAnalyzersAndStates) ||
projectAnalyzersAndStates == null)
{
return null;
}
return projectAnalyzersAndStates.GetDiagnosticState(stateType, providerId);
}
private async Task HandleSuppressedAnalyzerAsync(Project project, ProviderId providerId, DiagnosticAnalyzer provider, CancellationToken cancellationToken)
{
var state = _analyzersAndState.GetOrCreateDiagnosticState(StateType.Project, providerId, provider, project.Id, project.Language);
var existingData = await state.TryGetExistingDataAsync(project, cancellationToken).ConfigureAwait(false);
if (existingData != null && existingData.Items.Length > 0)
{
await RemoveCacheDataAsync(project, state, providerId, cancellationToken).ConfigureAwait(false);
}
}
/// <summary>
/// Get the unique state name for the given {type, provider} tuple.
/// Note that this name is used by the underlying persistence stream of the corresponding <see cref="DiagnosticState"/> to Read/Write diagnostic data into the stream.
/// If any two distinct {type, provider} tuples have the same diagnostic state name, we will end up sharing the persistence stream between them, leading to duplicate/missing/incorrect diagnostic data.
/// </summary>
private static ValueTuple<string, VersionStamp> GetUniqueDiagnosticStateNameAndVersion(StateType type, ProviderId providerId, DiagnosticAnalyzer provider)
{
Contract.ThrowIfNull(provider);
// Get the unique ID for given diagnostic analyzer.
// note that we also put version stamp so that we can detect changed provider
var providerType = provider.GetType();
var location = providerType.Assembly.Location;
return ValueTuple.Create(UserDiagnosticsPrefixTableName + "_" + type + "_" + providerType.AssemblyQualifiedName, GetProviderVersion(location));
}
internal static DiagnosticState GetOrCreateDiagnosticState(DiagnosticState[,] diagnosticStateMaps, StateType stateType, int providerIndex, ProviderId providerId, DiagnosticAnalyzer provider, string language)
{
Contract.ThrowIfFalse(providerIndex >= 0);
Contract.ThrowIfFalse(providerIndex < diagnosticStateMaps.GetLength(1));
if (diagnosticStateMaps[(int)stateType, providerIndex] == null)
{
var nameAndVersion = GetUniqueDiagnosticStateNameAndVersion(stateType, providerId, provider);
var name = nameAndVersion.Item1;
var version = nameAndVersion.Item2;
diagnosticStateMaps[(int)stateType, providerIndex] = new DiagnosticState(name, version, language);
#if DEBUG
// Ensure diagnostic state name is indeed unique.
foreach (var type in s_documentScopeStateTypes)
{
for (var pId = 0; pId < diagnosticStateMaps.GetLength(1); pId++)
{
if (diagnosticStateMaps[(int)type, pId] != null)
{
Contract.ThrowIfFalse(name != diagnosticStateMaps[(int)type, pId].Name ||
(stateType == type &&
(pId == providerIndex || language != diagnosticStateMaps[(int)type, pId].Language)));
}
}
}
#endif
}
return diagnosticStateMaps[(int)stateType, providerIndex];
}
protected override Task<AnalysisData> GetSpecificDiagnosticsAsync(
Solution solution, DiagnosticAnalyzer provider, ProviderId providerId, StateType stateType, VersionArgument versions, DiagnosticAnalyzerDriver analyzerDriver)
{
switch (stateType)
{
case StateType.Syntax:
return this.AnalyzerExecutor.GetSyntaxAnalysisDataAsync(provider, providerId, versions, analyzerDriver);
case StateType.Document:
return this.AnalyzerExecutor.GetDocumentAnalysisDataAsync(provider, providerId, versions, analyzerDriver);
case StateType.Project:
return this.AnalyzerExecutor.GetProjectAnalysisDataAsync(provider, providerId, versions, analyzerDriver);
default:
return Contract.FailWithReturn<Task<AnalysisData>>("Can't reach here");
}
}
