Exemple #1
0
        public static AggregateRowInfo CreateAndSaveAggregateInfo(OnDemandProcessingContext odpContext)
        {
            AggregateRowInfo aggregateRowInfo = new AggregateRowInfo();

            aggregateRowInfo.SaveAggregateInfo(odpContext);
            return(aggregateRowInfo);
        }
        protected override void SendToInner()
        {
            bool peerOuterGroupProcessing = base.m_odpContext.PeerOuterGroupProcessing;

            base.m_dataRegionDef.RuntimeDataRegionObj = base.m_selfReference;
            int num = (this.m_outerGroupings != null) ? this.m_outerGroupings.Length : 0;
            AggregateRowInfo aggregateRowInfo = AggregateRowInfo.CreateAndSaveAggregateInfo(base.m_odpContext);

            if (base.m_dataRegionDef.IsMatrixIDC)
            {
                if (this.m_innerGroupings != null)
                {
                    this.ProcessInnerHierarchy(aggregateRowInfo);
                }
                for (int i = 0; i < num; i++)
                {
                    this.ProcessOuterHierarchy(aggregateRowInfo, i);
                }
            }
            else
            {
                if (num == 0)
                {
                    if (this.m_innerGroupings != null)
                    {
                        this.ProcessInnerHierarchy(aggregateRowInfo);
                    }
                }
                else
                {
                    if (this.m_innerGroupsWithCellsForOuterPeerGroupProcessing == null || !peerOuterGroupProcessing)
                    {
                        this.m_innerGroupsWithCellsForOuterPeerGroupProcessing = new List <IReference <RuntimeDataTablixGroupLeafObj> >();
                    }
                    for (int j = 0; j < num; j++)
                    {
                        this.ProcessOuterHierarchy(aggregateRowInfo, j);
                        if (this.m_innerGroupings != null)
                        {
                            if (j == 0)
                            {
                                this.ProcessInnerHierarchy(aggregateRowInfo);
                            }
                            else
                            {
                                foreach (IReference <RuntimeDataTablixGroupLeafObj> item in this.m_innerGroupsWithCellsForOuterPeerGroupProcessing)
                                {
                                    using (item.PinValue())
                                    {
                                        item.Value().PeerOuterGroupProcessCells();
                                    }
                                    aggregateRowInfo.RestoreAggregateInfo(base.m_odpContext);
                                }
                            }
                        }
                    }
                }
                base.m_odpContext.PeerOuterGroupProcessing = peerOuterGroupProcessing;
            }
        }
 private void ProcessInnerHierarchy(AggregateRowInfo aggregateRowInfo)
 {
     for (int i = 0; i < this.m_innerGroupings.Length; i++)
     {
         IReference <RuntimeMemberObj> reference = this.m_innerGroupings[i];
         using (reference.PinValue())
         {
             reference.Value().NextRow(false, base.m_odpContext);
         }
         aggregateRowInfo.RestoreAggregateInfo(base.m_odpContext);
     }
 }
        private void ProcessOuterHierarchy(AggregateRowInfo aggregateRowInfo, int outerGroupingIndex)
        {
            base.m_odpContext.PeerOuterGroupProcessing = (outerGroupingIndex != 0);
            base.m_dataRegionDef.ResetOuterGroupingIndexesForOuterPeerGroup(0);
            base.m_dataRegionDef.ResetOuterGroupingAggregateRowInfo();
            base.m_dataRegionDef.SetDataTablixAggregateRowInfo(aggregateRowInfo);
            IReference <RuntimeMemberObj> reference = this.m_outerGroupings[outerGroupingIndex];

            using (reference.PinValue())
            {
                reference.Value().NextRow(true, base.m_odpContext);
            }
            aggregateRowInfo.RestoreAggregateInfo(base.m_odpContext);
        }
        public void FirstPassNextDataRow(OnDemandProcessingContext odpContext)
        {
            AggregateRowInfo aggregateRowInfo = AggregateRowInfo.CreateAndSaveAggregateInfo(odpContext);

            for (int i = 0; i < this.m_dataRegionObjs.Count; i++)
            {
                RuntimeDataRegionObjReference runtimeDataRegionObjReference = this.m_dataRegionObjs[i];
                if ((BaseReference)runtimeDataRegionObjReference != (object)null)
                {
                    using (runtimeDataRegionObjReference.PinValue())
                    {
                        runtimeDataRegionObjReference.Value().NextRow();
                    }
                    aggregateRowInfo.RestoreAggregateInfo(odpContext);
                }
            }
        }
Exemple #6
0
        public void CombineAggregateInfo(OnDemandProcessingContext odpContext, AggregateRowInfo updated)
        {
            FieldsImpl fieldsImpl = odpContext.ReportObjectModel.FieldsImpl;

            if (updated == null)
            {
                fieldsImpl.ValidAggregateRow = false;
            }
            else
            {
                if (!updated.m_validAggregateRow)
                {
                    fieldsImpl.ValidAggregateRow = false;
                }
                for (int i = 0; i < fieldsImpl.Count; i++)
                {
                    if (updated.m_aggregationFieldChecked[i])
                    {
                        fieldsImpl.ConsumeAggregationField(i);
                    }
                }
            }
        }
Exemple #7
0
 public override void SaveAggregateInfo(OnDemandProcessingContext odpContext)
 {
     this.m_aggregateInfo = new AggregateRowInfo();
     this.m_aggregateInfo.SaveAggregateInfo(odpContext);
 }