/// <summary>
        /// fetch-and-compute loop
        /// </summary>
        /// <returns></returns>
        private bool FindMatchingRecord()
        {
            bool recordFound = false;

            if (!StartPosition.IsZero)
            {
                GatewayResult result = TaskViews.OpenCursors(Reverse, StartPosition);

                if (result.Success)
                {
                    IRecord record;
                    // Looking for one record only
                    do
                    {
                        record = GetBasicRecord();
                        if (record != null && RecordComputer.Compute(record, true, false, false).Success)
                        {
                            recordFound = true;
                            break;
                        }
                    } while (record != null);
                }

                TaskViews.CloseMainCursor();
            }
            return(recordFound);
        }
示例#2
0
        /// <summary>
        /// Build
        /// </summary>
        /// <returns></returns>
        internal override RecordComputer Build()
        {
            RecordComputer recordComputer = base.Build();

            recordComputer.Add(new LocateNextComputeStrategy(StartPosition));

            return(recordComputer);
        }
        internal override ReturnResultBase Execute()
        {
            GatewayResult  result         = new GatewayResult();
            RecordComputer recordComputer = TaskViews.RecordComputer;

            recordComputer.RecomputeUnit(UnitId, Record);
            return(result);
        }
示例#4
0
        public GatewayResult AddDataControlView(RuntimeReadOnlyView view, DcValuesBuilderBase dcValuesBuilder)
        {
            GatewayResult result = null;

            DataControlViews.Add(view);
            int boundControlId = ((DataControlSourceViewDefinition)view.DataSourceViewDefinition).BoundControlId;
            var dsId           = view.DataSourceViewDefinition.TaskDataSource.DataSourceDefinition.Id;
            var strategy       = new DataControlValuesComputeStrategy(boundControlId, dcValuesBuilder, view.RangeBuilder, dsId);
            var unitId         = RecomputeIdFactory.GetRecomputeId(typeof(DcValues), boundControlId);

            RecordComputer.Add(unitId, strategy);
            result = view.OpenDataSource();
            view.BuildCursor();

            if (result.Success)
            {
                view.Prepare();
            }

            return(result);
        }
        /// <summary>
        /// Execute
        /// </summary>
        /// <returns></returns>
        internal override ReturnResultBase Execute()
        {
            ReturnResultBase result = new ReturnResult();

            // initialize the start position from which next record to be located.
            initStartPosition();

            //Build Record computer
            RecordComputerBuilder recordComputerBuilder = new LocateNextRecordComputerBuilder(StartPosition)
            {
                LocalDataviewManager = LocalDataviewManager,
                TaskViews            = TaskViews
            };

            recordComputer = recordComputerBuilder.Build();

            //Locate Next record from current start position.
            base.Execute();

            return(result);
        }
示例#6
0
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        internal override ReturnResultBase Execute()
        {
            IRangeDataBuilder origRangeDataBuilder = null;
            IFieldView        fieldView            = TaskViews.Fields[fieldId];

            // Initialize the stuff needed to locate the right record
            if (!fieldView.IsVirtual && !fieldView.IsLink)
            {
                // set the range builder, which will pass the data to the gateway
                origRangeDataBuilder            = TaskViews.ViewMain.RangeBuilder;
                TaskViews.ViewMain.RangeBuilder = new IncrementalLocateRangeDataBuilder(TaskViews.ViewMain.ViewBoundaries, minValue, fieldView);
                // use the base record computer - no need for extra computing after the fetch
                recordComputer = base.RecordComputer;
            }
            else
            {
                // the gateway will not compute it for us - need to use a special record computer
                RecordComputerBuilder recordComputerBuilder = new IncrementalLocateRecordComputerBuilder(fieldView, minValue)
                {
                    LocalDataviewManager = LocalDataviewManager,
                    TaskViews            = TaskViews
                };
                recordComputer = recordComputerBuilder.Build();
            }

            TaskViews.ViewMain.CurrentCursor = TaskViews.ViewMain.LocateCursor;

            // try and get a matching record
            base.Execute();

            TaskViews.ViewMain.CurrentCursor = TaskViews.ViewMain.defaultCursor;

            // restore ViewMain state
            if (origRangeDataBuilder != null)
            {
                TaskViews.ViewMain.RangeBuilder = origRangeDataBuilder;
            }

            return(new GatewayResult());
        }
        internal override ReturnResultBase Execute()
        {
            bool isEmptyDataView = ((DataView)(Task.DataView)).isEmptyDataview();

            DataviewSynchronizer.SetupDataview(Reverse);

            IRecord origRecord = DataviewSynchronizer.GetCurrentRecord();

            TaskViews.ViewMain.IgnorePositionCache = true;

            GatewayResult result = TaskViews.OpenCursors(Reverse, new DbPos(true));

            if (result.Success)
            {
                IRecord record;
                while ((record = GetBasicRecord()) != null)
                {
                    if (RecordComputer.Compute(record, true, false, false).Success)
                    {
                        //execute event OnRecordFetchEvent
                        onRecordFetch((Record)record);
                        DataviewSynchronizer.RemoveRecord(record);
                    }
                }
            }
            TaskViews.CloseMainCursor();

            TaskViews.ViewMain.IgnorePositionCache = false;

            if (origRecord != null)
            {
                DataviewSynchronizer.SetCurrentRecord(origRecord != null ? origRecord.getId() : Int32.MinValue);
                ((DataView)(Task.DataView)).takeFldValsFromCurrRec();
            }

            ((DataView)(Task.DataView)).setEmptyDataview(isEmptyDataView);

            return(result);
        }
示例#8
0
        /// <summary>
        /// execute command
        /// </summary>
        internal override ReturnResultBase Execute()
        {
            DataviewSynchronizer.SetupDataview(Reverse);
            GatewayResult    gatewayResult = SetupMainCursor();
            ReturnResultBase result;
            int fetchedRecordNumber = 0;

            if (gatewayResult.Success)
            {
                for (fetchedRecordNumber = 0; !StopFetches(fetchedRecordNumber);)
                {
                    IRecord record = GetBasicRecord();
                    if (record != null && RecordComputer.Compute(record, true, false, false).Success)
                    {
                        fetchedRecordNumber++;
                    }
                }
            }
            else
            {
                UpdateViewEnd(gatewayResult);
            }

            TaskViews.CloseMainCursor();

            //If PerformUpdateAfterFetch is false , the UpdateAterFetch () should be called only if recs are fetched.
            if (gatewayResult.Success && (PerformUpdateAfterFetch || fetchedRecordNumber > 0))
            {
                result = UpdateAfterFetch();
            }
            else
            {
                result = gatewayResult;
            }
            return(result);
        }
示例#9
0
 internal void SetLocateExpressionRecordComputer(RecordComputer recordComputer)
 {
     // This method should be called once only.
     Debug.Assert(LocateExpressionRecordComputer == null);
     LocateExpressionRecordComputer = recordComputer;
 }
示例#10
0
 internal void SetRecordsComputer(RecordComputer recordComputer)
 {
     // This method should be called once only.
     Debug.Assert(RecordComputer == null);
     RecordComputer = recordComputer;
 }