/// <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 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); }
/// <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"); } }