private void SetValue(object value, bool internalSet, out bool succeeded) { succeeded = false; if (!internalSet) { if (!IsReportVariable || !m_variableDef.Writable) { return; } m_result = new Microsoft.ReportingServices.RdlExpressions.VariantResult(errorOccurred: false, value); bool flag = m_reportRT.ProcessSerializableResult(isReportScope: true, ref m_result); if (m_result.ErrorOccurred) { if (flag) { ((IErrorContext)m_reportRT).Register(ProcessingErrorCode.rsVariableTypeNotSerializable, Severity.Error, m_parentObjectType, m_parentObjectName, m_variableDef.GetPropertyName(), Array.Empty <string>()); } } else { m_reportRT.ReportObjectModel.OdpContext.StoreUpdatedVariableValue(m_indexInCollection, value); succeeded = true; m_value = value; m_isValueReady = true; } } else { succeeded = true; m_value = value; m_isValueReady = true; } }
internal void ResetAll(Microsoft.ReportingServices.RdlExpressions.VariantResult aResult) { foreach (ReportItemImpl value in m_collection.Values) { value.Reset(aResult); } }
private void CheckExprResultError(Microsoft.ReportingServices.RdlExpressions.VariantResult result) { if (result.ErrorOccurred) { throw new ReportProcessingException_InvalidOperationException(); } }
internal bool EvaluateParameters(out object[] values, out DataFieldStatus fieldStatus) { bool flag = false; fieldStatus = DataFieldStatus.None; values = new object[m_aggregateDef.Expressions.Length]; for (int i = 0; i < m_aggregateDef.Expressions.Length; i++) { try { Microsoft.ReportingServices.RdlExpressions.VariantResult variantResult = m_reportRT.EvaluateAggregateVariantOrBinaryParamExpr(m_aggregateDef, i, this); values[i] = variantResult.Value; flag |= variantResult.ErrorOccurred; if (variantResult.FieldStatus != 0) { fieldStatus = variantResult.FieldStatus; } } catch (ReportProcessingException_MissingAggregateDependency) { if (m_aggregateDef.AggregateType == DataAggregateInfo.AggregateTypes.Previous) { values[i] = null; fieldStatus = DataFieldStatus.None; return(false); } Global.Tracer.Assert(condition: false, "Unfulfilled aggregate dependency outside of a previous"); throw; } } return(flag); }
private object EvaluateFilterValue(Microsoft.ReportingServices.ReportIntermediateFormat.Filter filterDef) { Global.Tracer.Assert(filterDef.Values != null, "(filterDef.Values != null)"); Global.Tracer.Assert(filterDef.Values.Count > 0, "(filterDef.Values.Count > 0)"); Microsoft.ReportingServices.RdlExpressions.VariantResult variantResult = m_processingContext.ReportRuntime.EvaluateFilterVariantValue(filterDef, 0, m_objectType, m_objectName); ThrowIfErrorOccurred("FilterValue", variantResult.ErrorOccurred, variantResult.FieldStatus); return(variantResult.Value); }
internal override object EvaluateValidValueLabelExpr(IParameterDef aParamDef, int aIndex) { Microsoft.ReportingServices.RdlExpressions.VariantResult variantResult = GetOnDemandContext().ReportRuntime.EvaluateParamValidValueLabel((Microsoft.ReportingServices.ReportIntermediateFormat.ParameterDef)aParamDef, aIndex); if (variantResult.ErrorOccurred) { throw new ReportProcessingException(ErrorCode.rsReportParameterProcessingError, aParamDef.Name); } return(variantResult.Value); }
internal void NextRow() { long streamOffset = m_odpContext.ReportObjectModel.FieldsImpl.StreamOffset; int num = -1; CommonRowCache tablixProcessingLookupRowCache = m_odpContext.TablixProcessingLookupRowCache; if (m_mustBufferAllRows) { num = tablixProcessingLookupRowCache.AddRow(RuntimeDataTablixObj.SaveData(m_odpContext)); if (m_firstRowCacheIndex == -1) { m_firstRowCacheIndex = num; } } IScalabilityCache tablixProcessingScalabilityCache = m_odpContext.TablixProcessingScalabilityCache; for (int i = 0; i < m_dataSet.LookupDestinationInfos.Count; i++) { LookupDestinationInfo lookupDestinationInfo = m_dataSet.LookupDestinationInfos[i]; LookupObjResult lookupObjResult = m_dataSetInstance.LookupResults[i]; if (lookupObjResult.ErrorOccured) { continue; } Microsoft.ReportingServices.RdlExpressions.VariantResult variantResult = lookupDestinationInfo.EvaluateDestExpr(m_odpContext, lookupObjResult); if (variantResult.ErrorOccurred) { lookupObjResult.DataFieldStatus = variantResult.FieldStatus; continue; } object value = variantResult.Value; LookupTable lookupTable = lookupObjResult.GetLookupTable(m_odpContext); try { if (!lookupTable.TryGetAndPinValue(value, out LookupMatches matches, out IDisposable cleanupRef)) { matches = ((!lookupDestinationInfo.UsedInSameDataSetTablixProcessing) ? new LookupMatches() : new LookupMatchesWithRows()); cleanupRef = lookupTable.AddAndPin(value, matches); } if (lookupDestinationInfo.IsMultiValue || !matches.HasRow) { matches.AddRow(streamOffset, num, tablixProcessingScalabilityCache); } cleanupRef.Dispose(); } catch (ReportProcessingException_SpatialTypeComparisonError reportProcessingException_SpatialTypeComparisonError) { throw new ReportProcessingException(m_lookupOwner.RegisterSpatialElementComparisonError(reportProcessingException_SpatialTypeComparisonError.Type)); } } if (!m_mustBufferAllRows) { m_lookupOwner.PostLookupNextRow(); } }
internal string GetFormattedValue(Microsoft.ReportingServices.RdlExpressions.VariantResult originalValue, IReportScopeInstance reportScopeInstance, OnDemandProcessingContext context) { context.SetupContext(InstancePath, reportScopeInstance); if (originalValue.ErrorOccurred) { return(RPRes.rsExpressionErrorValue); } if (originalValue.Value != null) { return(Formatter.Format(originalValue.Value, ref m_formatter, m_chart.StyleClass, m_styleClass, context, Microsoft.ReportingServices.ReportProcessing.ObjectType.Chart, m_chart.Name)); } return(null); }
internal string FormatTextRunValue(Microsoft.ReportingServices.RdlExpressions.VariantResult textRunResult, OnDemandProcessingContext context) { string result = null; if (textRunResult.ErrorOccurred) { result = RPRes.rsExpressionErrorValue; } else if (textRunResult.Value != null) { result = FormatTextRunValue(textRunResult.Value, textRunResult.TypeCode, null, context); } return(result); }
private void Parse() { if (m_parsed) { return; } try { m_parsed = true; m_paragraphDef.CriGenerationPhase = ReportElement.CriGenerationPhases.Definition; m_textRunDef.CriGenerationPhase = ReportElement.CriGenerationPhases.Definition; ReportEnumProperty <MarkupType> markupType = m_textRunDef.MarkupType; MarkupType markupType2 = (!markupType.IsExpression) ? markupType.Value : m_textRunDef.Instance.MarkupType; RichTextParser richTextParser = null; if (markupType2 != MarkupType.HTML) { return; } richTextParser = new HtmlParser(m_multipleParagraphsAllowed, this, this); InternalTextRunInstance internalTextRunInstance = (InternalTextRunInstance)m_textRunDef.Instance; Microsoft.ReportingServices.RdlExpressions.VariantResult originalValue = internalTextRunInstance.GetOriginalValue(); if (!originalValue.ErrorOccurred && originalValue.TypeCode != 0) { try { string richText = (originalValue.TypeCode != TypeCode.String) ? internalTextRunInstance.TextRunDef.FormatTextRunValue(originalValue.Value, originalValue.TypeCode, m_textRunDef.RenderingContext.OdpContext) : (originalValue.Value as string); m_compiledParagraphCollection = (CompiledParagraphInstanceCollection)richTextParser.Parse(richText); } catch (Exception ex) { m_errorContext.Register(ProcessingErrorCode.rsInvalidRichTextParseFailed, Severity.Warning, "TextRun", internalTextRunInstance.TextRunDef.Name, ex.Message); m_parseErrorOccured = true; CreateSingleTextRun().Value = RPRes.rsRichTextParseErrorValue; } } else { ICompiledTextRunInstance compiledTextRunInstance = CreateSingleTextRun(); if (originalValue.ErrorOccurred) { compiledTextRunInstance.Value = RPRes.rsExpressionErrorValue; } } } finally { m_textRunDef.CriGenerationPhase = ReportElement.CriGenerationPhases.None; m_paragraphDef.CriGenerationPhase = ReportElement.CriGenerationPhases.None; } }
internal string FormatText(Microsoft.ReportingServices.RdlExpressions.VariantResult result, OnDemandProcessingContext context) { string result2 = null; if (result.ErrorOccurred) { result2 = RPRes.rsExpressionErrorValue; } else if (result.Value != null) { result2 = Formatter.Format(result.Value, ref m_formatter, m_gaugePanel.StyleClass, m_styleClass, context, Microsoft.ReportingServices.ReportProcessing.ObjectType.GaugePanel, m_gaugePanel.Name); } return(result2); }
internal string GetFormattedStringFromValue(ref Microsoft.ReportingServices.RdlExpressions.VariantResult result, OnDemandProcessingContext context) { string result2 = null; if (result.ErrorOccurred) { result2 = RPRes.rsExpressionErrorValue; } else if (result.Value != null) { result2 = Formatter.Format(result.Value, ref m_formatter, base.StyleClass, null, context, ObjectType, base.Name); } return(result2); }
private object GetResult(bool fromValue) { if (fromValue && !VariableInScope) { return(null); } if (!m_isValueReady) { if (m_isVisited) { ProcessingErrorCode code = IsReportVariable ? ProcessingErrorCode.rsCyclicExpressionInReportVariable : ProcessingErrorCode.rsCyclicExpressionInGroupVariable; ((IErrorContext)m_reportRT).Register(code, Severity.Error, m_parentObjectType, m_parentObjectName, m_variableDef.GetPropertyName(), Array.Empty <string>()); throw new ReportProcessingException(m_reportRT.RuntimeErrorContext.Messages); } m_isVisited = true; bool variableReferenceMode = m_reportRT.VariableReferenceMode; ObjectType objectType = m_reportRT.ObjectType; string objectName = m_reportRT.ObjectName; string propertyName = m_reportRT.PropertyName; bool unfulfilledDependency = m_reportRT.UnfulfilledDependency; IScope currentScope = m_reportRT.CurrentScope; m_reportRT.VariableReferenceMode = true; m_reportRT.UnfulfilledDependency = false; m_result = m_reportRT.EvaluateVariableValueExpression(m_variableDef, m_exprHost, m_parentObjectType, m_parentObjectName, IsReportVariable); bool unfulfilledDependency2 = m_reportRT.UnfulfilledDependency; m_reportRT.UnfulfilledDependency |= unfulfilledDependency; m_reportRT.VariableReferenceMode = variableReferenceMode; m_reportRT.CurrentScope = currentScope; m_reportRT.ObjectType = objectType; m_reportRT.ObjectName = objectName; m_reportRT.PropertyName = propertyName; if (m_result.ErrorOccurred) { throw new ReportProcessingException(m_reportRT.RuntimeErrorContext.Messages); } if (unfulfilledDependency2 && fromValue) { m_value = null; m_isValueReady = false; } else { m_value = m_result.Value; m_isValueReady = true; } m_isVisited = false; } return(m_value); }
private object[] EvaluateFilterValues(Microsoft.ReportingServices.ReportIntermediateFormat.Filter filterDef) { if (filterDef.Values != null) { object[] array = new object[filterDef.Values.Count]; for (int num = filterDef.Values.Count - 1; num >= 0; num--) { Microsoft.ReportingServices.RdlExpressions.VariantResult variantResult = m_processingContext.ReportRuntime.EvaluateFilterVariantValue(filterDef, num, m_objectType, m_objectName); ThrowIfErrorOccurred("FilterValues", variantResult.ErrorOccurred, variantResult.FieldStatus); array[num] = variantResult.Value; } return(array); } return(null); }
internal string EvaluateText(IReportScopeInstance reportScopeInstance, OnDemandProcessingContext context) { context.SetupContext(m_gaugePanel, reportScopeInstance); Microsoft.ReportingServices.RdlExpressions.VariantResult variantResult = context.ReportRuntime.EvaluateCustomLabelTextExpression(this, m_gaugePanel.Name); string result = null; if (variantResult.ErrorOccurred) { result = RPRes.rsExpressionErrorValue; } else if (variantResult.Value != null) { result = Formatter.Format(variantResult.Value, ref m_formatter, m_gaugePanel.StyleClass, m_styleClass, context, Microsoft.ReportingServices.ReportProcessing.ObjectType.GaugePanel, m_gaugePanel.Name); } return(result); }
internal string EvaluateToolTip(IReportScopeInstance reportScopeInstance, OnDemandProcessingContext context) { context.SetupContext(InstancePath, reportScopeInstance); Microsoft.ReportingServices.RdlExpressions.VariantResult variantResult = context.ReportRuntime.EvaluateChartEmptyPointsToolTipExpression(this, m_chart.Name); string result = null; if (variantResult.ErrorOccurred) { result = RPRes.rsExpressionErrorValue; } else if (variantResult.Value != null) { result = Formatter.Format(variantResult.Value, ref m_formatter, m_chart.StyleClass, m_styleClass, context, base.ObjectType, base.Name); } return(result); }
internal bool CalculateDuplicates(Microsoft.ReportingServices.RdlExpressions.VariantResult currentResult, OnDemandProcessingContext context) { bool flag = false; if (m_hideDuplicates != null) { if (m_hasOldResult) { if (currentResult.ErrorOccurred && m_oldResult.ErrorOccurred) { flag = true; } else if (currentResult.ErrorOccurred) { flag = false; } else if (m_oldResult.ErrorOccurred) { flag = false; } else if (currentResult.Value == null && m_oldResult.Value == null) { flag = true; } else if (currentResult.Value == null) { flag = false; } else { flag = (Microsoft.ReportingServices.ReportProcessing.ReportProcessing.CompareTo(currentResult.Value, m_oldResult.Value, (context.CurrentOdpDataSetInstance != null) ? context.CurrentOdpDataSetInstance.DataSetDef.NullsAsBlanks : context.NullsAsBlanks, (context.CurrentOdpDataSetInstance != null) ? context.CurrentOdpDataSetInstance.CompareInfo : context.CompareInfo, (context.CurrentOdpDataSetInstance != null) ? context.CurrentOdpDataSetInstance.ClrCompareOptions : context.ClrCompareOptions, throwExceptionOnComparisonFailure: false, extendedTypeComparisons: false, out bool validComparisonResult) == 0); if (!validComparisonResult) { flag = false; } } } if (!flag) { m_hasOldResult = true; m_oldResult = currentResult; } } return(flag); }
private void CalculateValue() { if (m_isVisited) { m_iErrorContext.Register(ProcessingErrorCode.rsCyclicExpression, Severity.Warning, ObjectType.Field, m_fieldDef.Name, "Value"); throw new ReportProcessingException_InvalidOperationException(); } m_isVisited = true; Microsoft.ReportingServices.RdlExpressions.VariantResult variantResult = m_reportRT.EvaluateFieldValueExpression(m_fieldDef); m_value = variantResult.Value; m_errorOccurred = variantResult.ErrorOccurred; if (m_errorOccurred) { m_exceptionMessage = variantResult.ExceptionMessage; } m_isVisited = false; m_isValueReady = true; }
internal Microsoft.ReportingServices.RdlExpressions.VariantResult GetResult(IReportScopeInstance romInstance) { if (!m_isValueReady) { if (m_isVisited) { m_iErrorContext.Register(ProcessingErrorCode.rsCyclicExpression, Severity.Warning, m_textRunDef.ObjectType, m_textRunDef.Name, "Value"); throw new ReportProcessingException_InvalidOperationException(); } m_isVisited = true; ObjectType objectType = m_reportRT.ObjectType; string objectName = m_reportRT.ObjectName; string propertyName = m_reportRT.PropertyName; IScope currentScope = m_reportRT.CurrentScope; m_reportRT.CurrentScope = m_scope; OnDemandProcessingContext odpContext = m_reportRT.ReportObjectModel.OdpContext; ObjectModelImpl reportObjectModel = m_reportRT.ReportObjectModel; try { odpContext.SetupContext(m_textBoxDef, romInstance); bool num = (m_textRunDef.Action != null && m_textRunDef.Action.TrackFieldsUsedInValueExpression) || (m_textBoxDef != null && m_textBoxDef.Action != null && m_textBoxDef.Action.TrackFieldsUsedInValueExpression); if (num) { reportObjectModel.ResetFieldsUsedInExpression(); } m_result = m_reportRT.EvaluateTextRunValueExpression(m_textRunDef); if (num) { m_fieldsUsedInValueExpression = new List <string>(); reportObjectModel.AddFieldsUsedInExpression(m_fieldsUsedInValueExpression); } } finally { m_reportRT.CurrentScope = currentScope; m_reportRT.ObjectType = objectType; m_reportRT.ObjectName = objectName; m_reportRT.PropertyName = propertyName; m_isVisited = false; m_isValueReady = true; } } return(m_result); }
internal string GetFormattedLabelValue(Microsoft.ReportingServices.RdlExpressions.VariantResult labelObject, OnDemandProcessingContext context) { string result = null; if (labelObject.ErrorOccurred) { result = RPRes.rsExpressionErrorValue; } else if (labelObject.Value != null) { TypeCode typeCode = Type.GetTypeCode(labelObject.Value.GetType()); if (m_formatter == null) { m_formatter = new Formatter(base.DataRegionDef.StyleClass, context, Microsoft.ReportingServices.ReportProcessing.ObjectType.Chart, base.DataRegionDef.Name); } result = m_formatter.FormatValue(labelObject.Value, typeCode); } return(result); }
internal Microsoft.ReportingServices.RdlExpressions.VariantResult[] EvaluateJoinConditionKeys(bool evaluatePrimaryKeys, Microsoft.ReportingServices.RdlExpressions.ReportRuntime reportRuntime) { int joinConditionCount = JoinConditionCount; if (joinConditionCount == 0) { return(null); } Microsoft.ReportingServices.RdlExpressions.VariantResult[] array = new Microsoft.ReportingServices.RdlExpressions.VariantResult[joinConditionCount]; for (int i = 0; i < joinConditionCount; i++) { if (evaluatePrimaryKeys) { array[i] = m_joinConditions[i].EvaluatePrimaryKeyExpr(reportRuntime); } else { array[i] = m_joinConditions[i].EvaluateForeignKeyExpr(reportRuntime); } } return(array); }
internal string EvaluateCaption(IReportScopeInstance reportScopeInstance, OnDemandProcessingContext context) { context.SetupContext(m_map, reportScopeInstance); Microsoft.ReportingServices.RdlExpressions.VariantResult result = context.ReportRuntime.EvaluateMapLegendTitleCaptionExpression(this, m_map.Name); return(m_map.GetFormattedStringFromValue(ref result, context)); }
internal override void EvaluateScopedFieldReference(string scopeName, int fieldIndex, ref Microsoft.ReportingServices.RdlExpressions.VariantResult result) { Global.Tracer.Assert(m_lastRIFObject != null, "The RIF object for the current scope should be present."); try { if (!m_odpContext.ReportDefinition.MappingNameToDataSet.TryGetValue(scopeName, out Microsoft.ReportingServices.ReportIntermediateFormat.DataSet value)) { throw new ReportProcessingException_NonExistingScopeReference(scopeName); } if (!TryGetNonStructuralIdcDataManager(value, out NonStructuralIdcDataManager nsIdcDataManager)) { nsIdcDataManager = CreateNonStructuralIdcDataManager(scopeName, value); } if (nsIdcDataManager.SourceDataScope.CurrentStreamingScopeInstance != nsIdcDataManager.LastParentScopeInstance) { nsIdcDataManager.RegisterActiveParent(nsIdcDataManager.SourceDataScope.CurrentStreamingScopeInstance); nsIdcDataManager.Advance(); } else { nsIdcDataManager.SetupEnvironment(); } m_odpContext.ReportRuntime.EvaluateSimpleFieldReference(fieldIndex, ref result); } finally { SetupEnvironment(m_lastRIFObject, m_lastOnDemandScopeInstance.Value(), m_lastOnDemandScopeInstance); } }
internal override void EvaluateScopedFieldReference(string scopeName, int fieldIndex, ref Microsoft.ReportingServices.RdlExpressions.VariantResult result) { FireAssert("EvaluateScopedFieldReference"); }
internal Microsoft.ReportingServices.RdlExpressions.VariantResult GetResult(IReportScopeInstance romInstance, bool calledFromValue) { if (calledFromValue && !IsTextboxInScope()) { m_result = default(Microsoft.ReportingServices.RdlExpressions.VariantResult); } else if (!m_isValueReady) { if (m_isVisited) { m_iErrorContext.Register(ProcessingErrorCode.rsCyclicExpression, Severity.Warning, m_textBox.ObjectType, m_textBox.Name, "Value"); throw new ReportProcessingException_InvalidOperationException(); } m_isVisited = true; _ = m_reportRT.ReportObjectModel; OnDemandProcessingContext odpContext = m_reportRT.ReportObjectModel.OdpContext; bool contextUpdated = m_reportRT.ContextUpdated; IInstancePath originalObject = null; m_reportRT.ContextUpdated = false; if (odpContext.IsTablixProcessingMode || calledFromValue) { originalObject = odpContext.LastRIFObject; } bool flag = m_textBox.Action != null && m_textBox.Action.TrackFieldsUsedInValueExpression; Dictionary <string, bool> dictionary = null; if (flag) { dictionary = new Dictionary <string, bool>(); } try { bool flag2 = false; if (m_paragraphs.Count == 1) { TextRunsImpl textRunsImpl = (TextRunsImpl)m_paragraphs[0].TextRuns; if (textRunsImpl.Count == 1) { flag2 = true; TextRunImpl textRunImpl = (TextRunImpl)textRunsImpl[0]; m_result = textRunImpl.GetResult(romInstance); if (flag) { textRunImpl.MergeFieldsUsedInValueExpression(dictionary); } } } if (!flag2) { bool flag3 = false; m_result = default(Microsoft.ReportingServices.RdlExpressions.VariantResult); StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i < m_paragraphs.Count; i++) { if (i > 0) { flag3 = true; stringBuilder.Append(Environment.NewLine); } TextRunsImpl textRunsImpl2 = (TextRunsImpl)m_paragraphs[i].TextRuns; for (int j = 0; j < textRunsImpl2.Count; j++) { TextRunImpl textRunImpl2 = (TextRunImpl)textRunsImpl2[j]; Microsoft.ReportingServices.RdlExpressions.VariantResult result = textRunImpl2.GetResult(romInstance); if (result.Value != null) { if (result.TypeCode == TypeCode.Object && (result.Value is TimeSpan || result.Value is DateTimeOffset)) { string text = textRunImpl2.TextRunDef.FormatTextRunValue(result, odpContext); if (text != null) { result.Value = text; } else { result.Value = Microsoft.ReportingServices.RdlExpressions.ReportRuntime.ConvertToStringFallBack(result.Value); } } flag3 = true; stringBuilder.Append(result.Value); } if (flag) { textRunImpl2.MergeFieldsUsedInValueExpression(dictionary); } } } if (flag3) { m_result.Value = stringBuilder.ToString(); m_result.TypeCode = TypeCode.String; } } if (flag) { m_fieldsUsedInValueExpression = new List <string>(); foreach (string key in dictionary.Keys) { m_fieldsUsedInValueExpression.Add(key); } } } finally { odpContext.RestoreContext(originalObject); m_reportRT.ContextUpdated = contextUpdated; m_isVisited = false; m_isValueReady = true; } } return(m_result); }
internal void SetResult(Microsoft.ReportingServices.RdlExpressions.VariantResult result) { m_result = result; m_isValueReady = true; }
internal override void Reset(Microsoft.ReportingServices.RdlExpressions.VariantResult value) { SetResult(value); }
internal abstract void Reset(Microsoft.ReportingServices.RdlExpressions.VariantResult aResult);
internal object[] EvaluateLookup() { bool flag = m_lookupInfo.ReturnFirstMatchOnly(); OnDemandProcessingContext odpContext = m_reportRuntime.ReportObjectModel.OdpContext; Microsoft.ReportingServices.ReportIntermediateFormat.DataSet dataSet = odpContext.ReportDefinition.MappingDataSetIndexToDataSet[m_lookupInfo.DataSetIndexInCollection]; DataSetInstance dataSetInstance = odpContext.GetDataSetInstance(dataSet); if (dataSetInstance == null) { throw new ReportProcessingException_InvalidOperationException(); } if (dataSetInstance.NoRows) { return(EmptyResult); } if (dataSetInstance.LookupResults == null || dataSetInstance.LookupResults[m_lookupInfo.DestinationIndexInCollection] == null) { if (!odpContext.CalculateLookup(m_lookupInfo)) { return(EmptyResult); } Global.Tracer.Assert(dataSetInstance.LookupResults != null, "Lookup not initialized correctly by tablix processing"); } LookupObjResult lookupObjResult = dataSetInstance.LookupResults[m_lookupInfo.DestinationIndexInCollection]; if (lookupObjResult.ErrorOccured) { IErrorContext reportRuntime = m_reportRuntime; if (lookupObjResult.DataFieldStatus == DataFieldStatus.None && lookupObjResult.ErrorCode != 0) { reportRuntime.Register(lookupObjResult.ErrorCode, lookupObjResult.ErrorSeverity, lookupObjResult.ErrorMessageArgs); } else if (lookupObjResult.DataFieldStatus == DataFieldStatus.UnSupportedDataType) { reportRuntime.Register(ProcessingErrorCode.rsLookupOfInvalidExpressionDataType, Severity.Warning, lookupObjResult.ErrorMessageArgs); } throw new ReportProcessingException_InvalidOperationException(); } Microsoft.ReportingServices.RdlExpressions.VariantResult result = m_lookupInfo.EvaluateSourceExpr(m_reportRuntime); CheckExprResultError(result); bool flag2 = lookupObjResult.HasBeenTransferred || odpContext.CurrentDataSetIndex != dataSet.IndexInCollection; List <object> list = null; CompareInfo compareInfo = null; CompareOptions clrCompareOptions = CompareOptions.None; bool nullsAsBlanks = false; bool useOrdinalStringKeyGeneration = false; try { if (flag2) { compareInfo = odpContext.CompareInfo; clrCompareOptions = odpContext.ClrCompareOptions; nullsAsBlanks = odpContext.NullsAsBlanks; useOrdinalStringKeyGeneration = odpContext.UseOrdinalStringKeyGeneration; dataSetInstance.SetupCollationSettings(odpContext); } LookupTable lookupTable = lookupObjResult.GetLookupTable(odpContext); Global.Tracer.Assert(lookupTable != null, "LookupTable must not be null"); ObjectModelImpl reportObjectModel = odpContext.ReportObjectModel; Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.DataChunkReader dataChunkReader = null; if (flag2) { dataChunkReader = odpContext.GetDataChunkReader(dataSet.IndexInCollection); } using (reportObjectModel.SetupNewFieldsWithBackup(dataSet, dataSetInstance, dataChunkReader)) { object[] array = result.Value as object[]; if (array == null) { array = new object[1] { result.Value }; } else { list = new List <object>(array.Length); } object[] array2 = array; foreach (object key in array2) { if (lookupTable.TryGetValue(key, out LookupMatches matches)) { int num = flag ? 1 : matches.MatchCount; if (list == null) { list = new List <object>(num); } for (int j = 0; j < num; j++) { matches.SetupRow(j, odpContext); Microsoft.ReportingServices.RdlExpressions.VariantResult result2 = m_lookupInfo.EvaluateResultExpr(m_reportRuntime); CheckExprResultError(result2); list.Add(result2.Value); } } } } } finally { if (compareInfo != null) { odpContext.SetComparisonInformation(compareInfo, clrCompareOptions, nullsAsBlanks, useOrdinalStringKeyGeneration); } } object[] result3 = EmptyResult; if (list != null) { result3 = list.ToArray(); } return(result3); }
internal bool PassFilters(object dataInstance, out bool specialFilter) { bool flag = true; specialFilter = false; if (m_failFilters) { return(false); } if (m_filters != null) { for (int num = m_startFilterIndex; num < m_filters.Count; num++) { Microsoft.ReportingServices.ReportIntermediateFormat.Filter filter = m_filters[num]; if (Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.Like == filter.Operator) { Microsoft.ReportingServices.RdlExpressions.StringResult stringResult = m_processingContext.ReportRuntime.EvaluateFilterStringExpression(filter, m_objectType, m_objectName); ThrowIfErrorOccurred("FilterExpression", stringResult.ErrorOccurred, stringResult.FieldStatus); Global.Tracer.Assert(filter.Values != null, "(null != filter.Values)"); Global.Tracer.Assert(1 <= filter.Values.Count, "(1 <= filter.Values.Count)"); Microsoft.ReportingServices.RdlExpressions.StringResult stringResult2 = m_processingContext.ReportRuntime.EvaluateFilterStringValue(filter, 0, m_objectType, m_objectName); ThrowIfErrorOccurred("FilterValue", stringResult2.ErrorOccurred, stringResult2.FieldStatus); if (stringResult.Value != null && stringResult2.Value != null) { if (!StringType.StrLikeText(stringResult.Value, stringResult2.Value)) { flag = false; } } else if (stringResult.Value != null || stringResult2.Value != null) { flag = false; } } else { Microsoft.ReportingServices.RdlExpressions.VariantResult variantResult = m_processingContext.ReportRuntime.EvaluateFilterVariantExpression(filter, m_objectType, m_objectName); ThrowIfErrorOccurred("FilterExpression", variantResult.ErrorOccurred, variantResult.FieldStatus); object value = variantResult.Value; if (filter.Operator == Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.Equal || Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.NotEqual == filter.Operator || Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.GreaterThan == filter.Operator || Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.GreaterThanOrEqual == filter.Operator || Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.LessThan == filter.Operator || Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.LessThanOrEqual == filter.Operator) { object value2 = EvaluateFilterValue(filter); int num2 = 0; try { num2 = Compare(value, value2); } catch (ReportProcessingException_SpatialTypeComparisonError reportProcessingException_SpatialTypeComparisonError) { throw new ReportProcessingException(RegisterSpatialTypeComparisonError(reportProcessingException_SpatialTypeComparisonError.Type)); } catch (ReportProcessingException_ComparisonError e) { throw new ReportProcessingException(RegisterComparisonError(e)); } catch (Exception e2) { if (AsynchronousExceptionDetection.IsStoppingException(e2)) { throw; } throw new ReportProcessingException(RegisterComparisonError()); } if (flag) { switch (filter.Operator) { case Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.Equal: if (num2 != 0) { flag = false; } break; case Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.NotEqual: if (num2 == 0) { flag = false; } break; case Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.GreaterThan: if (0 >= num2) { flag = false; } break; case Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.GreaterThanOrEqual: if (0 > num2) { flag = false; } break; case Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.LessThan: if (0 <= num2) { flag = false; } break; case Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.LessThanOrEqual: if (0 < num2) { flag = false; } break; } } } else if (Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.In == filter.Operator) { object[] array = EvaluateFilterValues(filter); flag = false; if (array != null) { for (int i = 0; i < array.Length; i++) { try { if (array[i] is ICollection) { foreach (object item in (ICollection)array[i]) { if (Compare(value, item) == 0) { flag = true; break; } } } else if (Compare(value, array[i]) == 0) { flag = true; } if (flag) { goto IL_05e1; } } catch (ReportProcessingException_SpatialTypeComparisonError reportProcessingException_SpatialTypeComparisonError2) { throw new ReportProcessingException(RegisterSpatialTypeComparisonError(reportProcessingException_SpatialTypeComparisonError2.Type)); } catch (ReportProcessingException_ComparisonError e3) { throw new ReportProcessingException(RegisterComparisonError(e3)); } catch (Exception e4) { if (AsynchronousExceptionDetection.IsStoppingException(e4)) { throw; } throw new ReportProcessingException(RegisterComparisonError()); } } } } else if (Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.Between == filter.Operator) { object[] array2 = EvaluateFilterValues(filter); flag = false; Global.Tracer.Assert(array2 != null && 2 == array2.Length, "(null != values && 2 == values.Length)"); try { if (0 <= Compare(value, array2[0]) && 0 >= Compare(value, array2[1])) { flag = true; } } catch (ReportProcessingException_SpatialTypeComparisonError reportProcessingException_SpatialTypeComparisonError3) { throw new ReportProcessingException(RegisterSpatialTypeComparisonError(reportProcessingException_SpatialTypeComparisonError3.Type)); } catch (ReportProcessingException_ComparisonError e5) { throw new ReportProcessingException(RegisterComparisonError(e5)); } catch (RSException) { throw; } catch (Exception e6) { if (AsynchronousExceptionDetection.IsStoppingException(e6)) { throw; } throw new ReportProcessingException(RegisterComparisonError()); } } else if (Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.TopN == filter.Operator || Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.BottomN == filter.Operator) { if (m_filterInfo == null) { Global.Tracer.Assert(filter.Values != null && 1 == filter.Values.Count, "(null != filter.Values && 1 == filter.Values.Count)"); Microsoft.ReportingServices.RdlExpressions.IntegerResult integerResult = m_processingContext.ReportRuntime.EvaluateFilterIntegerValue(filter, 0, m_objectType, m_objectName); ThrowIfErrorOccurred("FilterValue", integerResult.ErrorOccurred, integerResult.FieldStatus); int value3 = integerResult.Value; IComparer comparer = (Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.TopN != filter.Operator) ? ((IComparer) new MyBottomComparer(m_processingContext.ProcessingComparer)) : ((IComparer) new MyTopComparer(m_processingContext.ProcessingComparer)); InitFilterInfos(new MySortedListWithMaxSize(comparer, value3, this), num); } SortAndSave(value, dataInstance); flag = false; specialFilter = true; } else if (Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.TopPercent == filter.Operator || Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.BottomPercent == filter.Operator) { if (m_filterInfo == null) { Global.Tracer.Assert(filter.Values != null && 1 == filter.Values.Count, "(null != filter.Values && 1 == filter.Values.Count)"); Microsoft.ReportingServices.RdlExpressions.FloatResult floatResult = m_processingContext.ReportRuntime.EvaluateFilterIntegerOrFloatValue(filter, 0, m_objectType, m_objectName); ThrowIfErrorOccurred("FilterValue", floatResult.ErrorOccurred, floatResult.FieldStatus); double value4 = floatResult.Value; IComparer comparer2 = (Microsoft.ReportingServices.ReportIntermediateFormat.Filter.Operators.TopPercent != filter.Operator) ? ((IComparer) new MyBottomComparer(m_processingContext.ProcessingComparer)) : ((IComparer) new MyTopComparer(m_processingContext.ProcessingComparer)); InitFilterInfos(new MySortedListWithoutMaxSize(comparer2, this), num); m_filterInfo.Percentage = value4; m_filterInfo.Operator = filter.Operator; } SortAndSave(value, dataInstance); flag = false; specialFilter = true; } } goto IL_05e1; IL_05e1: if (!flag) { return(false); } } } return(flag); }