public IEnumerable <DynamicJsonValue> AddCurrentToResults(RangeGroup range, double?scale) { if (_interpolationType != InterpolationType.None) { foreach (var gap in FillMissingGaps(range, scale)) { yield return(gap); } } foreach (var kvp in _current) { var key = kvp.Key; var value = kvp.Value; if (value[0].Any == false) { continue; } yield return(ToJson(scale, range.Start, range.End, key, value)); if (_interpolationType == InterpolationType.None) { _pool.Free(value); continue; } UpdatePrevious(key, range, value); } _current = null; }
/// <summary> /// Creates a new range group info. /// </summary> /// <param name="model">The range group model</param> /// <param name="start">The starting group index</param> /// <param name="end">The ending group index</param> /// <param name="level">The level for the group</param> internal RangeGroupInfo(RangeGroup model, int start, int end, int level) { this.model = model; this.Start = start; this.End = end; this.Level = level; }
public static RangeGroup ParseRangeFromString(string s, DateTime?from = null) { var range = new RangeGroup(); var offset = 0; var duration = ParseNumber(s, ref offset); ParseRange(s, ref offset, ref range, duration); while (offset < s.Length && char.IsWhiteSpace(s[offset])) { offset++; } if (offset != s.Length) { throw new ArgumentException("After range specification, found additional unknown data: " + s); } if (from != null && range.Ticks != 0) { var ticks = from.Value.Ticks; ticks -= (ticks % range.AlignedTicks); range._start = new DateTime(ticks); } return(range); }
private void UpdatePrevious(object key, RangeGroup range, ITimeSeriesAggregation[] values) { _previous ??= new Dictionary <object, PreviousAggregation>(); if (_previous.TryGetValue(key, out var result) == false) { result = _previous[key] = new PreviousAggregation(); } else { _pool.Free(result.Data); } result.Data = values; result.Range = range; }
public RangeStringInputViewModel(PreflopStrategy strategy) { this.strategy = strategy; RangeGroups = new List<RangeGroup>(); foreach (string groupKey in strategy.HandRangeGroupKeys) { RangeGroup group = new RangeGroup() { Key = groupKey, Ranges = new List<Range>() }; foreach (string rangeKey in strategy.HandRangeKeys) group.Ranges.Add(new Range() { Key = rangeKey, Value = string.Empty }); RangeGroups.Add(group); } }
public void CanGetRangeStartAndNext(string rangeStr, string dateStr, string startStr, string nextStr) { var rangeSpec = RangeGroup.ParseRangeFromString(rangeStr); var date = DateTime.ParseExact(dateStr, "o", CultureInfo.InvariantCulture).ToUniversalTime(); rangeSpec.InitializeRange(date); Assert.Equal( DateTime.ParseExact(startStr, "o", CultureInfo.InvariantCulture).ToUniversalTime(), rangeSpec.Start); rangeSpec.MoveToNextRange(rangeSpec.End); Assert.Equal( DateTime.ParseExact(nextStr, "o", CultureInfo.InvariantCulture).ToUniversalTime(), rangeSpec.Start); }
public static TimeValue LastWithTime(MethodExpression expression, string queryText, BlittableJsonReaderObject parameters) { try { if (expression.Arguments.Count != 2) { throw new InvalidOperationException("Method 'last()' expects two arguments to be provided"); } var duration = Helpers.GetLong(expression.Arguments[0], parameters); var timeValueUnitAsString = Helpers.GetString(expression.Arguments[1], parameters); var offset = 0; return(RangeGroup.ParseTimePeriodFromString(duration, timeValueUnitAsString, ref offset)); } catch (Exception e) { throw new InvalidQueryException("Could not parse last() method.", queryText, parameters, e); } }
public static RangeGroup ParseRangeFromString(string s) { var range = new RangeGroup(); var offset = 0; var duration = ParseNumber(s, ref offset); ParseRange(s, ref offset, ref range, duration); while (offset < s.Length && char.IsWhiteSpace(s[offset])) { offset++; } if (offset != s.Length) { throw new ArgumentException("After range specification, found additional unknown data: " + s); } return(range); }
public RangeStringInputViewModel(PreflopStrategy strategy) { this.strategy = strategy; RangeGroups = new List <RangeGroup>(); foreach (string groupKey in strategy.HandRangeGroupKeys) { RangeGroup group = new RangeGroup() { Key = groupKey, Ranges = new List <Range>() }; foreach (string rangeKey in strategy.HandRangeKeys) { group.Ranges.Add(new Range() { Key = rangeKey, Value = string.Empty }); } RangeGroups.Add(group); } }
private static void ParseRange(string source, ref int offset, ref RangeGroup range, long duration) { if (offset >= source.Length) { throw new ArgumentException("Unable to find range specification in: " + source); } while (char.IsWhiteSpace(source[offset]) && offset < source.Length) { offset++; } if (offset >= source.Length) { throw new ArgumentException("Unable to find range specification in: " + source); } switch (char.ToLower(source[offset++])) { case 's': if (TryConsumeMatch(source, ref offset, "seconds") == false) { TryConsumeMatch(source, ref offset, "second"); } range.Ticks += duration * TicksInOneSecond; range.TicksAlignment = Alignment.Second; return; case 'm': if (TryConsumeMatch(source, ref offset, "minutes") || TryConsumeMatch(source, ref offset, "minute") || TryConsumeMatch(source, ref offset, "min")) { range.Ticks += duration * TicksInOneSecond * 60; range.TicksAlignment = Alignment.Minute; return; } if (TryConsumeMatch(source, ref offset, "ms") || TryConsumeMatch(source, ref offset, "milliseconds") || TryConsumeMatch(source, ref offset, "milli")) { range.Ticks += duration * TicksInMillisecond; range.TicksAlignment = Alignment.Millisecond; return; } if (TryConsumeMatch(source, ref offset, "months") || TryConsumeMatch(source, ref offset, "month") || TryConsumeMatch(source, ref offset, "mon") || TryConsumeMatch(source, ref offset, "mo")) { AssertValidDurationInMonths(duration); range.Months += (int)duration; return; } range.TicksAlignment = Alignment.Minute; range.Ticks += duration * TicksInOneSecond * 60; return; case 'h': if (TryConsumeMatch(source, ref offset, "hours") == false) { TryConsumeMatch(source, ref offset, "hour"); } range.Ticks += duration * TicksInOneSecond * 60 * 60; range.TicksAlignment = Alignment.Hour; return; case 'd': if (TryConsumeMatch(source, ref offset, "days") == false) { TryConsumeMatch(source, ref offset, "day"); } range.Ticks += duration * TicksInOneSecond * 60 * 60 * 24; range.TicksAlignment = Alignment.Day; return; case 'q': if (TryConsumeMatch(source, ref offset, "quarters") == false) { TryConsumeMatch(source, ref offset, "quarter"); } duration *= 3; AssertValidDurationInMonths(duration); range.Months += (int)duration; return; case 'y': if (TryConsumeMatch(source, ref offset, "years") == false) { TryConsumeMatch(source, ref offset, "year"); } duration *= 12; AssertValidDurationInMonths(duration); range.Months += (int)duration; return; default: throw new ArgumentException($"Unable to understand time range: '{source}'"); } }
public static void SaveColumnHeaderInfo(Worksheet sheet, CopyMoveCellsInfo headerCellsInfo, CopyMoveColumnsInfo columnsInfo, int baseColumn, CopyToOption option) { int rowCount = headerCellsInfo.RowCount; int columnCount = headerCellsInfo.ColumnCount; for (int i = 0; i < rowCount; i++) { for (int k = 0; k < columnCount; k++) { if ((option & CopyToOption.Value) > ((CopyToOption)0)) { headerCellsInfo.SaveValue(i, k, sheet.GetValue(i, baseColumn + k, SheetArea.ColumnHeader)); } if ((option & CopyToOption.Style) > ((CopyToOption)0)) { headerCellsInfo.SaveStyle(i, k, GetStyleObject(sheet, i, baseColumn + k, SheetArea.ColumnHeader)); } if ((option & CopyToOption.Tag) > ((CopyToOption)0)) { headerCellsInfo.SaveTag(i, k, sheet.GetTag(i, baseColumn + k, SheetArea.ColumnHeader)); } } } if ((option & CopyToOption.Value) > ((CopyToOption)0)) { for (int m = 0; m < columnCount; m++) { if (sheet.IsColumnBound(baseColumn + m)) { columnsInfo.SaveBindingField(m, sheet.GetDataColumnName(baseColumn + m)); } } } if ((option & CopyToOption.Span) > ((CopyToOption)0)) { IEnumerator enumerator = sheet.ColumnHeaderSpanModel.GetEnumerator(0, baseColumn, rowCount, columnCount); while (enumerator.MoveNext()) { headerCellsInfo.SaveSpan((CellRange)enumerator.Current); } } columnCount = columnsInfo.ColumnCount; for (int j = 0; j < columnCount; j++) { columnsInfo.SaveWidth(j, sheet.GetColumnWidth(baseColumn + j)); columnsInfo.SaveVisible(j, sheet.GetColumnVisible(baseColumn + j)); columnsInfo.SaveResizable(j, sheet.GetColumnResizable(baseColumn + j)); columnsInfo.SaveTag(j, sheet.GetTag(-1, baseColumn + j)); } if ((option & CopyToOption.Style) > ((CopyToOption)0)) { for (int n = 0; n < columnCount; n++) { columnsInfo.SaveViewportColumnStyle(n, GetStyleObject(sheet, -1, baseColumn + n, SheetArea.Cells)); columnsInfo.SaveHeaderColumnStyle(n, GetStyleObject(sheet, -1, baseColumn + n, SheetArea.ColumnHeader)); } } if ((option & CopyToOption.RangeGroup) > ((CopyToOption)0)) { RangeGroup columnRangeGroup = sheet.ColumnRangeGroup; if ((columnRangeGroup != null) && !columnRangeGroup.IsEmpty()) { for (int num8 = 0; num8 < columnCount; num8++) { columnsInfo.SaveRangeGroup(num8, columnRangeGroup.Data.GetLevel(baseColumn + num8), columnRangeGroup.Data.GetCollapsed(baseColumn + num8)); } } } }
public static List <SingleResult> GetAggregatedValues(TimeSeriesReader reader, RangeGroup rangeSpec, AggregationMode mode) { var aggStates = new TimeSeriesAggregation(mode); // we always will aggregate here by Min, Max, First, Last, Sum, Count, Mean var results = new List <SingleResult>(); foreach (var it in reader.SegmentsOrValues()) { if (it.IndividualValues != null) { AggregateIndividualItems(it.IndividualValues); } else { //We might need to close the old aggregation range and start a new one MaybeMoveToNextRange(it.Segment.Start); // now we need to see if we can consume the whole segment, or // if the range it cover needs to be broken up to multiple ranges. // For example, if the segment covers 3 days, but we have group by 1 hour, // we still have to deal with the individual values if (it.Segment.End > rangeSpec.End) { AggregateIndividualItems(it.Segment.Values); } else { var span = it.Segment.Summary.SegmentValues.Span; aggStates.Segment(span); } } } if (aggStates.Any) { var result = new SingleResult { Timestamp = rangeSpec.Start, Values = new Memory <double>(aggStates.Values.ToArray()), Status = TimeSeriesValuesSegment.Live, Type = SingleResultType.RolledUp // TODO: Tag = "" }; TimeSeriesStorage.AssertNoNanValue(result); results.Add(result); } return(results); void MaybeMoveToNextRange(DateTime ts) { if (rangeSpec.WithinRange(ts)) { return; } if (aggStates.Any) { var result = new SingleResult { Timestamp = rangeSpec.Start, Values = new Memory <double>(aggStates.Values.ToArray()), Status = TimeSeriesValuesSegment.Live, Type = SingleResultType.RolledUp // TODO: Tag = "" }; TimeSeriesStorage.AssertNoNanValue(result); results.Add(result); } rangeSpec.MoveToNextRange(ts); aggStates.Init(); } void AggregateIndividualItems(IEnumerable <SingleResult> items) { foreach (var cur in items) { if (cur.Status == TimeSeriesValuesSegment.Dead) { continue; } MaybeMoveToNextRange(cur.Timestamp); aggStates.Step(cur.Values.Span); } } }
private void RollupOne(DocumentsOperationContext context, Table table, RollupState item, TimeSeriesPolicy policy, TimeSeriesCollectionConfiguration config) { var tss = context.DocumentDatabase.DocumentsStorage.TimeSeriesStorage; var rawTimeSeries = item.Name.Split(TimeSeriesConfiguration.TimeSeriesRollupSeparator)[0]; var intoTimeSeries = policy.GetTimeSeriesName(rawTimeSeries); var rollupStart = item.NextRollup.Add(-policy.AggregationTime); if (config.MaxRetention < TimeValue.MaxValue) { var next = new DateTime(NextRollup(_now.Add(-config.MaxRetention), policy)).Add(-policy.AggregationTime); var rollupStartTicks = Math.Max(rollupStart.Ticks, next.Ticks); rollupStart = new DateTime(rollupStartTicks); } var intoReader = tss.GetReader(context, item.DocId, intoTimeSeries, rollupStart, DateTime.MaxValue); var previouslyAggregated = intoReader.AllValues().Any(); if (previouslyAggregated) { var changeVector = intoReader.GetCurrentSegmentChangeVector(); if (ChangeVectorUtils.GetConflictStatus(item.ChangeVector, changeVector) == ConflictStatus.AlreadyMerged) { // this rollup is already done table.DeleteByKey(item.Key); return; } } if (_isFirstInTopology == false) { return; } var rollupEnd = new DateTime(NextRollup(_now, policy)).Add(-policy.AggregationTime).AddMilliseconds(-1); var reader = tss.GetReader(context, item.DocId, item.Name, rollupStart, rollupEnd); if (previouslyAggregated) { var hasPriorValues = tss.GetReader(context, item.DocId, item.Name, DateTime.MinValue, rollupStart).AllValues().Any(); if (hasPriorValues == false) { table.DeleteByKey(item.Key); var first = tss.GetReader(context, item.DocId, item.Name, rollupStart, DateTime.MaxValue).First(); if (first == default) { return; } if (first.Timestamp > item.NextRollup) { // if the 'source' time-series doesn't have any values it is retained. // so we need to aggregate only from the next time frame using (var slicer = new TimeSeriesSliceHolder(context, item.DocId, item.Name, item.Collection)) { tss.Rollups.MarkForPolicy(context, slicer, policy, first.Timestamp); } return; } } } // rollup from the the raw data will generate 6-value roll up of (first, last, min, max, sum, count) // other rollups will aggregate each of those values by the type var mode = item.Name.Contains(TimeSeriesConfiguration.TimeSeriesRollupSeparator) ? AggregationMode.FromAggregated : AggregationMode.FromRaw; var rangeSpec = new RangeGroup(); switch (policy.AggregationTime.Unit) { case TimeValueUnit.Second: rangeSpec.Ticks = TimeSpan.FromSeconds(policy.AggregationTime.Value).Ticks; rangeSpec.TicksAlignment = RangeGroup.Alignment.Second; break; case TimeValueUnit.Month: rangeSpec.Months = policy.AggregationTime.Value; break; default: throw new ArgumentOutOfRangeException(nameof(policy.AggregationTime.Unit), $"Not supported time value unit '{policy.AggregationTime.Unit}'"); } rangeSpec.InitializeRange(rollupStart); var values = GetAggregatedValues(reader, rangeSpec, mode); if (previouslyAggregated) { // if we need to re-aggregate we need to delete everything we have from that point on. var removeRequest = new TimeSeriesStorage.DeletionRangeRequest { Collection = item.Collection, DocumentId = item.DocId, Name = intoTimeSeries, From = rollupStart, To = DateTime.MaxValue, }; tss.DeleteTimestampRange(context, removeRequest); } var before = context.LastDatabaseChangeVector; var after = tss.AppendTimestamp(context, item.DocId, item.Collection, intoTimeSeries, values, verifyName: false); if (before != after) { RolledUp++; } table.DeleteByKey(item.Key); var stats = tss.Stats.GetStats(context, item.DocId, item.Name); if (stats.End > rollupEnd) { // we know that we have values after the current rollup and we need to mark them var nextRollup = rollupEnd.AddMilliseconds(1); intoReader = tss.GetReader(context, item.DocId, item.Name, nextRollup, DateTime.MaxValue); if (intoReader.Init() == false) { Debug.Assert(false, "We have values but no segment?"); return; } using (var slicer = new TimeSeriesSliceHolder(context, item.DocId, item.Name, item.Collection)) { tss.Rollups.MarkForPolicy(context, slicer, policy, intoReader.First().Timestamp); } } }
protected override long ExecuteCmd(DocumentsOperationContext context) { var tss = context.DocumentDatabase.DocumentsStorage.TimeSeriesStorage; RollupSchema.Create(context.Transaction.InnerTransaction, TimeSeriesRollupTable, 16); var table = context.Transaction.InnerTransaction.OpenTable(RollupSchema, TimeSeriesRollupTable); foreach (var item in _states) { if (_configuration == null) { return(RolledUp); } if (_configuration.Collections.TryGetValue(item.Collection, out var config) == false) { continue; } if (config.Disabled) { continue; } if (table.ReadByKey(item.Key, out var current) == false) { continue; } var policy = config.GetPolicyByName(item.RollupPolicy, out _); if (policy == null) { table.DeleteByKey(item.Key); continue; } if (item.Etag != DocumentsStorage.TableValueToLong((int)RollupColumns.Etag, ref current)) { continue; // concurrency check } var rawTimeSeries = item.Name.Split(TimeSeriesConfiguration.TimeSeriesRollupSeparator)[0]; var intoTimeSeries = policy.GetTimeSeriesName(rawTimeSeries); var rollupStart = item.NextRollup.Add(-policy.AggregationTime); if (config.MaxRetention < TimeValue.MaxValue) { var next = new DateTime(NextRollup(_now.Add(-config.MaxRetention), policy)).Add(-policy.AggregationTime); var rollupStartTicks = Math.Max(rollupStart.Ticks, next.Ticks); rollupStart = new DateTime(rollupStartTicks); } var intoReader = tss.GetReader(context, item.DocId, intoTimeSeries, rollupStart, DateTime.MaxValue); var previouslyAggregated = intoReader.AllValues().Any(); if (previouslyAggregated) { var changeVector = intoReader.GetCurrentSegmentChangeVector(); if (ChangeVectorUtils.GetConflictStatus(item.ChangeVector, changeVector) == ConflictStatus.AlreadyMerged) { // this rollup is already done table.DeleteByKey(item.Key); continue; } } if (_isFirstInTopology == false) { continue; // we execute the actual rollup only on the primary node to avoid conflicts } var rollupEnd = new DateTime(NextRollup(_now, policy)).Add(-policy.AggregationTime).AddMilliseconds(-1); var reader = tss.GetReader(context, item.DocId, item.Name, rollupStart, rollupEnd); if (previouslyAggregated) { var hasPriorValues = tss.GetReader(context, item.DocId, item.Name, DateTime.MinValue, rollupStart).AllValues().Any(); if (hasPriorValues == false) { table.DeleteByKey(item.Key); var first = tss.GetReader(context, item.DocId, item.Name, rollupStart, DateTime.MaxValue).First(); if (first == default) { continue; // nothing we can do here } if (first.Timestamp > item.NextRollup) { // if the 'source' time-series doesn't have any values it is retained. // so we need to aggregate only from the next time frame using (var slicer = new TimeSeriesSliceHolder(context, item.DocId, item.Name, item.Collection)) { tss.Rollups.MarkForPolicy(context, slicer, policy, first.Timestamp); } continue; } } } // rollup from the the raw data will generate 6-value roll up of (first, last, min, max, sum, count) // other rollups will aggregate each of those values by the type var mode = item.Name.Contains(TimeSeriesConfiguration.TimeSeriesRollupSeparator) ? AggregationMode.FromAggregated : AggregationMode.FromRaw; var rangeSpec = new RangeGroup(); switch (policy.AggregationTime.Unit) { case TimeValueUnit.Second: rangeSpec.Ticks = TimeSpan.FromSeconds(policy.AggregationTime.Value).Ticks; rangeSpec.TicksAlignment = RangeGroup.Alignment.Second; break; case TimeValueUnit.Month: rangeSpec.Months = policy.AggregationTime.Value; break; default: throw new ArgumentOutOfRangeException(nameof(policy.AggregationTime.Unit), $"Not supported time value unit '{policy.AggregationTime.Unit}'"); } rangeSpec.InitializeRange(rollupStart); List <SingleResult> values = null; try { values = GetAggregatedValues(reader, rangeSpec, mode); } catch (RollupExceedNumberOfValuesException e) { var name = item.Name; var docId = item.DocId; try { var document = context.DocumentDatabase.DocumentsStorage.Get(context, item.DocId, throwOnConflict: false); docId = document?.Id ?? docId; name = tss.GetOriginalName(context, docId, name); } catch { // ignore } var msg = $"Rollup '{item.RollupPolicy}' for time-series '{name}' in document '{docId}' failed."; if (_logger.IsInfoEnabled) { _logger.Info(msg, e); } var alert = AlertRaised.Create(context.DocumentDatabase.Name, "Failed to perform rollup because the time-series has more than 5 values", msg, AlertType.RollupExceedNumberOfValues, NotificationSeverity.Warning, $"{item.DocId}/{item.Name}", new ExceptionDetails(e)); context.DocumentDatabase.NotificationCenter.Add(alert); continue; } if (previouslyAggregated) { // if we need to re-aggregate we need to delete everything we have from that point on. var removeRequest = new TimeSeriesStorage.DeletionRangeRequest { Collection = item.Collection, DocumentId = item.DocId, Name = intoTimeSeries, From = rollupStart, To = DateTime.MaxValue, }; tss.DeleteTimestampRange(context, removeRequest); } var before = context.LastDatabaseChangeVector; var after = tss.AppendTimestamp(context, item.DocId, item.Collection, intoTimeSeries, values, verifyName: false); if (before != after) { RolledUp++; } table.DeleteByKey(item.Key); var stats = tss.Stats.GetStats(context, item.DocId, item.Name); if (stats.End > rollupEnd) { // we know that we have values after the current rollup and we need to mark them var nextRollup = rollupEnd.AddMilliseconds(1); intoReader = tss.GetReader(context, item.DocId, item.Name, nextRollup, DateTime.MaxValue); if (intoReader.Init() == false) { Debug.Assert(false, "We have values but no segment?"); continue; } using (var slicer = new TimeSeriesSliceHolder(context, item.DocId, item.Name, item.Collection)) { tss.Rollups.MarkForPolicy(context, slicer, policy, intoReader.First().Timestamp); } } } return(RolledUp); }
public static void SaveRowHeaderInfo(Worksheet sheet, CopyMoveCellsInfo headerCellsInfo, CopyMoveRowsInfo rowsInfo, int baseRow, CopyToOption option) { if ((option & CopyToOption.All) > ((CopyToOption)0)) { int rowCount = headerCellsInfo.RowCount; int columnCount = headerCellsInfo.ColumnCount; for (int i = 0; i < rowCount; i++) { for (int k = 0; k < columnCount; k++) { if ((option & CopyToOption.Value) > ((CopyToOption)0)) { headerCellsInfo.SaveValue(i, k, sheet.GetValue(baseRow + i, k, SheetArea.CornerHeader | SheetArea.RowHeader)); } if ((option & CopyToOption.Style) > ((CopyToOption)0)) { headerCellsInfo.SaveStyle(i, k, GetStyleObject(sheet, baseRow + i, k, SheetArea.CornerHeader | SheetArea.RowHeader)); } if ((option & CopyToOption.Tag) > ((CopyToOption)0)) { headerCellsInfo.SaveTag(i, k, sheet.GetTag(baseRow + i, k, SheetArea.CornerHeader | SheetArea.RowHeader)); } } } if ((option & CopyToOption.Span) > ((CopyToOption)0)) { IEnumerator enumerator = sheet.RowHeaderSpanModel.GetEnumerator(baseRow, 0, rowCount, columnCount); while (enumerator.MoveNext()) { headerCellsInfo.SaveSpan((CellRange)enumerator.Current); } } rowCount = rowsInfo.RowCount; for (int j = 0; j < rowCount; j++) { rowsInfo.SaveHeight(j, sheet.GetRowHeight(baseRow + j)); rowsInfo.SaveVisible(j, sheet.GetRowVisible(baseRow + j)); rowsInfo.SaveResizable(j, sheet.GetRowResizable(baseRow + j)); rowsInfo.SaveTag(j, sheet.GetTag(baseRow + j, -1)); } if ((option & CopyToOption.Style) > ((CopyToOption)0)) { for (int m = 0; m < rowCount; m++) { rowsInfo.SaveViewportRowStyle(m, GetStyleObject(sheet, baseRow + m, -1, SheetArea.Cells)); rowsInfo.SaveHeaderRowStyle(m, GetStyleObject(sheet, baseRow + m, -1, SheetArea.CornerHeader | SheetArea.RowHeader)); } } if ((option & CopyToOption.RangeGroup) > ((CopyToOption)0)) { RangeGroup rowRangeGroup = sheet.RowRangeGroup; if ((rowRangeGroup != null) && !rowRangeGroup.IsEmpty()) { for (int n = 0; n < rowCount; n++) { rowsInfo.SaveRangeGroup(n, rowRangeGroup.Data.GetLevel(baseRow + n), rowRangeGroup.Data.GetCollapsed(baseRow + n)); } } } } }
public static void UndoRowsInfo(Worksheet sheet, CopyMoveRowsInfo rowsInfo, int baseRow) { int rowCount = rowsInfo.RowCount; if (rowsInfo.IsHeightSaved()) { for (int i = 0; i < rowCount; i++) { sheet.SetRowHeight(baseRow + i, SheetArea.Cells, rowsInfo.GetHeight(i)); } } if (rowsInfo.IsVisibleSaved()) { for (int j = 0; j < rowCount; j++) { sheet.SetRowVisible(baseRow + j, SheetArea.Cells, rowsInfo.GetVisible(j)); } } if (rowsInfo.IsResizableSaved()) { for (int k = 0; k < rowCount; k++) { sheet.SetRowResizable(baseRow + k, SheetArea.Cells, rowsInfo.GetResizable(k)); } } if (rowsInfo.IsTagSaved()) { for (int m = 0; m < rowCount; m++) { sheet.SetTag(baseRow + m, -1, SheetArea.Cells, rowsInfo.GetTag(m)); } } if (rowsInfo.IsViewportRowStyleSaved()) { for (int n = 0; n < rowCount; n++) { SetStyleObject(sheet, baseRow + n, -1, SheetArea.Cells, rowsInfo.GetViewportRowStyle(n)); } } if (rowsInfo.IsHeaderRowStyleSaved()) { for (int num7 = 0; num7 < rowCount; num7++) { SetStyleObject(sheet, baseRow + num7, -1, SheetArea.CornerHeader | SheetArea.RowHeader, rowsInfo.GetHeaderRowStyle(num7)); } } if (rowsInfo.IsRangeGroupSaved()) { RangeGroup rowRangeGroup = sheet.RowRangeGroup; if (rowRangeGroup != null) { for (int num9 = 0; num9 < rowCount; num9++) { int num8; bool flag; rowsInfo.GetRangeGroup(num9, out num8, out flag); rowRangeGroup.Data.SetLevel(baseRow + num9, num8); rowRangeGroup.Data.SetCollapsed(baseRow + num9, flag); } } } }
public static void UndoColumnsInfo(Worksheet sheet, CopyMoveColumnsInfo columnsInfo, int baseColumn) { int columnCount = columnsInfo.ColumnCount; if (columnsInfo.IsBindingFieldSaved()) { for (int i = 0; i < columnCount; i++) { string str; if (columnsInfo.GetBindingField(i, out str)) { sheet.BindDataColumn(baseColumn + i, str); } } } else { for (int j = 0; j < columnCount; j++) { sheet.BindDataColumn(baseColumn + j, null); } } if (columnsInfo.IsWidthSaved()) { for (int k = 0; k < columnCount; k++) { sheet.SetColumnWidth(baseColumn + k, SheetArea.Cells, columnsInfo.GetWidth(k)); } } if (columnsInfo.IsVisibleSaved()) { for (int m = 0; m < columnCount; m++) { sheet.SetColumnVisible(baseColumn + m, SheetArea.Cells, columnsInfo.GetVisible(m)); } } if (columnsInfo.IsResizableSaved()) { for (int n = 0; n < columnCount; n++) { sheet.SetColumnResizable(baseColumn + n, SheetArea.Cells, columnsInfo.GetResizable(n)); } } if (columnsInfo.IsTagSaved()) { for (int num7 = 0; num7 < columnCount; num7++) { sheet.SetTag(-1, baseColumn + num7, SheetArea.Cells, columnsInfo.GetTag(num7)); } } if (columnsInfo.IsViewportColumnStyleSaved()) { for (int num8 = 0; num8 < columnCount; num8++) { SetStyleObject(sheet, -1, baseColumn + num8, SheetArea.Cells, columnsInfo.GetViewportColumnStyle(num8)); } } if (columnsInfo.IsHeaderColumnStyleSaved()) { for (int num9 = 0; num9 < columnCount; num9++) { SetStyleObject(sheet, -1, baseColumn + num9, SheetArea.ColumnHeader, columnsInfo.GetHeaderColumnStyle(num9)); } } if (columnsInfo.IsRangeGroupSaved()) { RangeGroup columnRangeGroup = sheet.ColumnRangeGroup; if (columnRangeGroup != null) { for (int num11 = 0; num11 < columnCount; num11++) { int num10; bool flag; columnsInfo.GetRangeGroup(num11, out num10, out flag); columnRangeGroup.Data.SetLevel(baseColumn + num11, num10); columnRangeGroup.Data.SetCollapsed(baseColumn + num11, flag); } } } }