public virtual void LoadData(ObjectId seekRowId, SeekDirection seekDirection, int rowCount)
{
this.contents = this.CreateListViewContents();
this.contents.DataSource = this.CreateDataSource(this.contents.Properties);
this.contents.DataSource.Load(seekRowId, seekDirection, rowCount);
this.SubscribeForFolderContentChanges();
}
public void Seek(bool dir)
{
SeekDirection d = SeekDirection.Forward;
if (dir == true)
{
d = SeekDirection.Forward;
}
else if (dir == false)
{
d = SeekDirection.Backward;
}
if (d == SeekDirection.Forward)
{
currentIndex = currentIndex + 1;
if (currentIndex == clips.Count)
{
currentIndex = 0;
}
}
else
{
currentIndex--;
if (currentIndex < 0)
{
currentIndex = clips.Count - 1;
}
}
}
private TimeSpan SeekNextPosition(SeekDirection direction, TimeSpan streamDuration)
{
// Compute new position based on direction and ESPlayer playback position.
_esPlayer.GetPlayingTime(out var position);
Log.Enter(position.ToString());
if (direction == SeekDirection.Forward)
{
position += SeekDistance;
if (position >= streamDuration)
{
position = streamDuration;
}
}
else
{
position -= SeekDistance;
if (position < TimeSpan.Zero)
{
position = TimeSpan.Zero;
}
}
Log.Exit(position.ToString());
return(position);
}
public IEnumerable <(byte[] Key, byte[] Value)> Seek(byte[] keyOrPrefix, SeekDirection direction)
{
if (keyOrPrefix == null)
{
keyOrPrefix = Array.Empty <byte>();
}
using var it = db.NewIterator(store.defaultFamily, options);
byte[] fullKey = keyOrPrefix;
if (direction == SeekDirection.Forward)
{
for (it.Seek(fullKey); it.Valid(); it.Next())
{
yield return(it.Key(), it.Value());
}
}
else
{
for (it.SeekForPrev(fullKey); it.Valid(); it.Prev())
{
yield return(it.Key(), it.Value());
}
}
}
// Token: 0x06001DDF RID: 7647 RVA: 0x000AD211 File Offset: 0x000AB411
public override void LoadAdjacent(ObjectId adjacentId, SeekDirection seekDirection, int rowCount)
{
if (!this.IsContactView)
{
throw new NotImplementedException();
}
base.LoadAdjacent(adjacentId, seekDirection, rowCount);
}
public IEnumerable <(byte[] Key, byte[] Value)> Seek(byte[]?key, SeekDirection direction)
{
if (disposed || db.Handle == IntPtr.Zero)
{
throw new ObjectDisposedException(nameof(RocksDbStore));
}
return(db.Seek(columnFamily, key, direction, readOptions));
}
private void StepForwardButton_Clicked(object sender, RoutedEventArgs e)
{
_isLeftMouseDown = true;
_seekDirection = SeekDirection.Forward;
if (!_myDispatcherTimer.IsEnabled)
{
_myDispatcherTimer.Start();
}
}
public virtual void LoadAdjacent(ObjectId adjacentId, SeekDirection seekDirection, int rowCount)
{
this.contents = this.CreateListViewContents();
this.contents.DataSource = this.CreateDataSource(this.contents.Properties);
if (!this.contents.DataSource.LoadAdjacent(adjacentId, seekDirection, rowCount))
{
this.forceRefresh = true;
}
this.SubscribeForFolderContentChanges();
}
/// <summary>
/// Missle Lock on behavior
/// </summary>
/// <returns>returns velocity vector facing player</returns>
private Vector3 Seek()
{
Vector3 SeekDirection;
SeekDirection = player.transform.position - transform.position;
SeekDirection.Normalize();
//Debug.DrawLine(transform.position, SeekDirection);
SeekDirection *= 20;
SeekDirection.z = 0;
return(SeekDirection);
}
public IEnumerable <(byte[] Key, byte[] Value)> Seek(byte[] keyOrPrefix, SeekDirection direction = SeekDirection.Forward)
{
ByteArrayComparer comparer = direction == SeekDirection.Forward ? ByteArrayComparer.Default : ByteArrayComparer.Reverse;
IEnumerable <KeyValuePair <byte[], byte[]> > records = immutableData;
if (keyOrPrefix?.Length > 0)
{
records = records.Where(p => comparer.Compare(p.Key, keyOrPrefix) >= 0);
}
records = records.OrderBy(p => p.Key, comparer);
return(records.Select(p => (p.Key, p.Value)));
}
private bool SeekDevice(SeekDirection direction)
{
this.ReadRegisters();
//Set Seek mode wrap bit
this.registers[RadioFM1.REGISTER_POWERCFG] &= 0xFBFF;
if (direction == SeekDirection.Backward)
{
this.registers[RadioFM1.REGISTER_POWERCFG] &= 0xFDFF; //Seek down is the default upon reset
}
else
{
this.registers[RadioFM1.REGISTER_POWERCFG] |= 1 << RadioFM1.BIT_SEEKUP; //Set the bit to Seek up
}
this.registers[RadioFM1.REGISTER_POWERCFG] |= (1 << RadioFM1.BIT_SEEK); //Start Seek
this.UpdateRegisters();
//Poll to see if STC is set
while (true)
{
this.ReadRegisters();
if ((this.registers[RadioFM1.REGISTER_STATUSRSSI] & (1 << RadioFM1.BIT_STC)) != 0)
{
break;
}
}
this.ReadRegisters();
int valueSFBL = this.registers[RadioFM1.REGISTER_STATUSRSSI] & (1 << RadioFM1.BIT_SFBL);
this.registers[RadioFM1.REGISTER_POWERCFG] &= 0xFEFF; //Clear the Seek bit after Seek has completed
this.UpdateRegisters();
//Wait for the si4703 to clear the STC as well
while (true)
{
this.ReadRegisters();
if ((this.registers[RadioFM1.REGISTER_STATUSRSSI] & (1 << RadioFM1.BIT_STC)) == 0)
{
break;
}
}
if (valueSFBL > 0) //The bit was set indicating we hit a band limit or failed to find a station
{
return(false);
}
return(true);
}
private Boolean SeekDevice(SeekDirection direction)
{
ReadRegisters();
//Set Seek mode wrap bit
_shadowRegisters[REGISTER_POWERCFG] &= 0xFBFF;
switch (direction)
{
case SeekDirection.Backward:
_shadowRegisters[REGISTER_POWERCFG] &= 0xFDFF; //Seek down is the default upon reset
break;
default:
_shadowRegisters[REGISTER_POWERCFG] |= 1 << BIT_SEEKUP; //Set the bit to Seek up
break;
}
_shadowRegisters[REGISTER_POWERCFG] |= 1 << BIT_SEEK; //Start Seek
UpdateRegisters();
// Poll to see if STC is set
while (true)
{
ReadRegisters();
if ((_shadowRegisters[REGISTER_STATUSRSSI] & (1 << BIT_STC)) != 0)
{
break;
}
}
ReadRegisters();
var valueSfbl = _shadowRegisters[REGISTER_STATUSRSSI] & (1 << BIT_SFBL);
_shadowRegisters[REGISTER_POWERCFG] &= 0xFEFF; //Clear the Seek bit after Seek has completed
UpdateRegisters();
//Wait for the si4703 to clear the STC as well
while (true)
{
ReadRegisters();
if ((_shadowRegisters[REGISTER_STATUSRSSI] & (1 << BIT_STC)) == 0)
{
break;
}
}
return(valueSfbl <= 0);
}
/// <summary>Tells the radio to Seek in the given direction until it finds a station.</summary>
/// <param name="direction">The direction to Seek the radio.</param>
/// <remarks>It does wrap around when seeking.</remarks>
/// <returns>The Channel that was tuned to or <see cref="INVALID_CHANNEL" /> if no Channel was found.</returns>
public double Seek(SeekDirection direction)
{
this.currentRadioText = "N/A";
if (this.SeekDevice(direction))
{
return(this.Channel);
}
else
{
return(RadioFM1.INVALID_CHANNEL);
}
}
public IEnumerable <(byte[] Key, byte[] Value)> Seek(byte[] keyOrPrefix, SeekDirection direction = SeekDirection.Forward)
{
if (keyOrPrefix == null)
{
keyOrPrefix = Array.Empty <byte>();
}
byte[] fullKey = keyOrPrefix;
using var it = db.NewIterator(defaultFamily, Options.ReadDefault);
if (direction == SeekDirection.Forward)
{
for (it.Seek(fullKey); it.Valid(); it.Next())
{
yield return(it.Key()[1..], it.Value());
void Seek(SeekDirection dir)
{
prevIndex = currentIndex;
if (dir == SeekDirection.Forward)
{
currentIndex = (currentIndex + 1) % clips.Count;
}
else if (dir == SeekDirection.Backward)
{
backwards++;
currentIndex = trackList[(trackList.Count - 1) - backwards];
//if (currentIndex < 0) currentIndex = clips.Count - 1;
}
}
// Token: 0x06002E6B RID: 11883 RVA: 0x00109268 File Offset: 0x00107468
private void Refresh(ListView.RenderFlags renderFlags, int startRange, SeekDirection direction)
{
this.PreRefresh();
if (startRange < 0)
{
startRange = 0;
}
ListView listView = this.GetListView();
IListViewDataSource dataSource = this.GetDataSource(listView);
this.LoadDataSource(dataSource, startRange, base.UserContext.UserOptions.ViewRowCount, direction);
listView.DataSource = dataSource;
this.WriteResponse(renderFlags, listView);
}
private bool SeekDevice(SeekDirection direction)
{
this.ReadRegisters();
this.registers[RadioFM1.REGISTER_POWERCFG] &= 0xFBFF;
if (direction == SeekDirection.Backward)
{
this.registers[RadioFM1.REGISTER_POWERCFG] &= 0xFDFF;
}
else
{
this.registers[RadioFM1.REGISTER_POWERCFG] |= 1 << RadioFM1.BIT_SEEKUP;
}
this.registers[RadioFM1.REGISTER_POWERCFG] |= (1 << RadioFM1.BIT_SEEK);
this.UpdateRegisters();
while (true)
{
this.ReadRegisters();
if ((this.registers[RadioFM1.REGISTER_STATUSRSSI] & (1 << RadioFM1.BIT_STC)) != 0)
{
break;
}
}
this.ReadRegisters();
int valueSFBL = this.registers[RadioFM1.REGISTER_STATUSRSSI] & (1 << RadioFM1.BIT_SFBL);
this.registers[RadioFM1.REGISTER_POWERCFG] &= 0xFEFF;
this.UpdateRegisters();
while (true)
{
this.ReadRegisters();
if ((this.registers[RadioFM1.REGISTER_STATUSRSSI] & (1 << RadioFM1.BIT_STC)) == 0)
{
break;
}
}
if (valueSFBL > 0)
{
return(false);
}
return(true);
}
public IEnumerable <(byte[] Key, byte[] Value)> Seek(byte[] keyOrPrefix, SeekDirection direction = SeekDirection.Forward)
{
ByteArrayComparer comparer = direction == SeekDirection.Forward ? ByteArrayComparer.Default : ByteArrayComparer.Reverse;
IEnumerable <KeyValuePair <byte[], byte[]> > records = innerData;
if (keyOrPrefix?.Length > 0)
{
records = records.Where(p => comparer.Compare(p.Key, keyOrPrefix) >= 0);
}
records = records.OrderBy(p => p.Key, comparer);
foreach (var pair in records)
{
yield return(pair.Key, pair.Value);
}
}
private void Seek(SeekDirection d)
{
if (d == SeekDirection.Forward)
{
currentIndex = (currentIndex + 1) % clips.Count;
}
else
{
currentIndex--;
if (currentIndex < 0)
{
currentIndex = clips.Count - 1;
}
}
}
public static MarkupType SeekMarkup(this byte[] array, out long position, SeekDirection direction = SeekDirection.Forward, int offset = 0, int _length = -1)
{
bool isFwd = (direction != SeekDirection.Forward) ? false : true;
short noiseFlag = 0;
MarkupType noiseKind = MarkupType.None;
MarkupType lastKind = MarkupType.None;
if (array.Length > 0)
{
long length = (_length <= 0 || _length > array.Length) ? array.Length : _length;
int arraylength = array.Length;
offset += (!isFwd) ? 1 : 0;
length -= ((!isFwd) ? 0 : 1);
for (int i = offset; i < length; i++)
{
byte checknoise = 0;
if (!isFwd)
{
checknoise = array[arraylength - i];
}
else
{
checknoise = array[i];
}
MarkupType tempKind = MarkupType.None;
if (checknoise.IsMarkup(out tempKind))
{
lastKind = tempKind;
noiseFlag++;
}
else if (noiseFlag >= 16)
{
noiseKind = lastKind;
position = (!isFwd) ? arraylength - i + 1 : i;
return(noiseKind);
}
else
{
lastKind = tempKind;
noiseFlag = 0;
}
}
}
position = (!isFwd && noiseFlag != 0) ? array.Length - noiseFlag + 1 : 0;
return(lastKind);
}
/// <summary>
/// Seeks in a direction for an element using a query
/// </summary>
/// <param name="query">Item to look for using the query</param>
/// <param name="dir">Direction to scroll in</param>
private void SeekToElement(Func <AppQuery, AppQuery> query, SeekDirection dir)
{
if (app.Query(query).Length == 0)
{
switch (dir)
{
case SeekDirection.Up:
app.ScrollUpTo(query);
break;
case SeekDirection.Down:
app.ScrollDownTo(query);
break;
}
}
}
protected DateTime?CalculateEnd(DateTime start, TimeSpan offset,
SeekDirection seekDirection, SeekBoundaryMode seekBoundaryMode)
{
if (offset < TimeSpan.Zero)
{
throw new InvalidOperationException("time span must be positive");
}
DateTime?endDate = null;
DateTime moment = start;
TimeSpan?remaining = offset;
Week week = new Week(start, Calendar);
// search end date, iteraring week by week
while (week != null)
{
base.IncludePeriods.Clear();
base.IncludePeriods.AddAll(GetAvailableWeekPeriods(week));
endDate = CalculateEnd(moment, remaining.Value, seekDirection, seekBoundaryMode, out remaining);
if (endDate != null || !remaining.HasValue)
{
break;
}
switch (seekDirection)
{
case SeekDirection.Forward:
week = FindNextWeek(week);
if (week != null)
{
moment = week.Start;
}
break;
case SeekDirection.Backward:
week = FindPreviousWeek(week);
if (week != null)
{
moment = week.End;
}
break;
}
}
return(endDate);
}
// ------------------------------------------------------------------------
protected CalendarVisitor(TFilter filter, ITimePeriod limits,
SeekDirection seekDirection = SeekDirection.Forward, ITimeCalendar calendar = null)
{
if (filter == null)
{
throw new ArgumentNullException("filter");
}
if (limits == null)
{
throw new ArgumentNullException("limits");
}
this.filter = filter;
this.limits = limits;
this.seekDirection = seekDirection;
this.calendar = calendar;
} // CalendarVisitor
// Token: 0x06002CB1 RID: 11441 RVA: 0x000FA3DC File Offset: 0x000F85DC
private void LoadNextOrPrevious(SeekDirection seekDirection)
{
try
{
ObjectId adjacentId = (ObjectId)base.GetParameter("AId");
int rowCount = this.GetRowCount();
VirtualListView2 listView = this.GetListView();
listView.LoadAdjacent(adjacentId, seekDirection, rowCount);
listView.RenderData(this.Writer);
listView.RenderChunk(this.Writer);
this.RenderExtraData(listView);
}
finally
{
this.EndProcessEvent();
}
}
public Day FindDay(Day start, int offset)
{
if (offset == 0)
{
return(start);
}
DaySeekerContext context = new DaySeekerContext(start, offset);
SeekDirection visitDirection = SeekDirection;
// reverse seek direction
if (offset < 0)
{
visitDirection = (visitDirection == SeekDirection.Forward) ?
SeekDirection.Backward :
SeekDirection.Forward;
}
StartDayVisit(start, context, visitDirection);
return(context.FoundDay);
}
// Token: 0x06002CB2 RID: 11442 RVA: 0x000FA44C File Offset: 0x000F864C
private void SeekNextOrPrevious(SeekDirection seekDirection)
{
try
{
ObjectId seekRowId = (ObjectId)base.GetParameter("SId");
int rowCount = this.GetRowCount();
VirtualListView2 listView = this.GetListView();
listView.LoadData(seekRowId, seekDirection, rowCount);
listView.RenderData(this.Writer);
listView.RenderChunk(this.Writer);
this.RenderExtraData(listView);
if (base.IsParameterSet("nwSel") && (bool)base.GetParameter("nwSel"))
{
this.RenderNewSelection(listView);
}
}
finally
{
this.EndProcessEvent();
}
}
public void Seek(bool dir)
{
SeekDirection d = SeekDirection.Forward;
if (dir == true)
{
d = SeekDirection.Forward;
}
else if (dir == false)
{
d = SeekDirection.Backward;
}
if (d == SeekDirection.Forward)
{
currentIndex = currentIndex + 1;
if (currentIndex == questions.Count)
{
currentIndex = 0;
}
currentQuestion.text = questions[currentIndex];
if (!currentAnswer.text.Contains(answers[currentIndex]))
{
currentAnswer.text += System.Environment.NewLine + (currentIndex + 1) + "." + answers[currentIndex];
}
}
else
{
currentIndex--;
if (currentIndex < 0)
{
currentIndex = questions.Count - 1;
}
currentQuestion.text = questions[currentIndex];
if (!currentAnswer.text.Contains(answers[currentIndex]))
{
currentAnswer.text += System.Environment.NewLine + (currentIndex + 1) + "." + answers[currentIndex];
}
}
}
public void Seek(bool dir)
{
SeekDirection d = SeekDirection.Forward;
if (dir == true)
{
d = SeekDirection.Forward;
}
else if (dir == false)
{
d = SeekDirection.Backward;
}
if (d == SeekDirection.Forward)
{
currentIndex = currentIndex + 1;
if (currentIndex == images.Count)
{
currentIndex = 0;
}
holder.sprite = images[currentIndex];
if (!output.text.Contains(holder.sprite.name))
{
output.text += System.Environment.NewLine + (currentIndex + 1) + "." + holder.sprite.name;
}
}
else
{
currentIndex--;
if (currentIndex < 0)
{
currentIndex = images.Count - 1;
}
holder.sprite = images[currentIndex];
if (!output.text.Contains(holder.sprite.name))
{
output.text += System.Environment.NewLine + (currentIndex + 1) + "." + holder.sprite.name;
}
}
}
private void StepForwardButton_Clicked(object sender, RoutedEventArgs e)
{
_isLeftMouseDown = true;
_seekDirection = SeekDirection.Forward;
if (!_myDispatcherTimer.IsEnabled)
{
_myDispatcherTimer.Start();
}
}
protected override IEnumerable <(StorageKey, StorageItem)> SeekInternal(byte[] keyOrPrefix, SeekDirection direction)
{
return(store.Seek(keyOrPrefix, direction).Select(p => (p.Key.AsSerializable <StorageKey>(), p.Value.AsSerializable <StorageItem>())));
}
// Token: 0x06002085 RID: 8325 RVA: 0x000BC534 File Offset: 0x000BA734
public new void Load(ObjectId seekToObjectId, SeekDirection seekDirection, int itemCount)
{
ExTraceGlobals.MailCallTracer.TraceDebug((long)this.GetHashCode(), "DumpsterListViewDataSource.Load(ObjectId seekToObjectId, SeekDirection seekDirection, int itemCount)");
if (itemCount < 1)
{
throw new ArgumentOutOfRangeException("itemCount", "itemCount must be greater than 0");
}
if (seekToObjectId == null)
{
throw new ArgumentNullException("seekToObjectId");
}
if (!base.UserHasRightToLoad)
{
return;
}
StoreObjectId storeObjectId = Utilities.TryGetStoreId(seekToObjectId) as StoreObjectId;
if (storeObjectId == null)
{
throw new ArgumentException("seekToObjectId could not be converted to a StoreObjectId");
}
PropertyDefinition[] requestedProperties = base.GetRequestedProperties();
using (QueryResult queryResult = base.Folder.FolderQuery(FolderQueryFlags.SoftDeleted, null, DumpsterListViewDataSource.folderSortBy, requestedProperties))
{
using (QueryResult queryResult2 = base.Folder.ItemQuery(ItemQueryType.SoftDeleted, null, base.SortBy, requestedProperties))
{
this.totalCount = queryResult.EstimatedRowCount + queryResult2.EstimatedRowCount;
object[][] itemsItemQuery = null;
if (this.totalCount != 0)
{
queryResult.SeekToCondition(SeekReference.OriginBeginning, new ComparisonFilter(ComparisonOperator.Equal, ItemSchema.Id, storeObjectId));
switch (seekDirection)
{
case SeekDirection.Next:
if (this.totalCount < queryResult.CurrentRow + itemCount + 1)
{
queryResult.SeekToOffset(SeekReference.OriginCurrent, this.totalCount - queryResult.CurrentRow - itemCount);
}
break;
case SeekDirection.Previous:
{
int offset;
if (queryResult.CurrentRow + 1 < itemCount)
{
offset = -1 * (queryResult.CurrentRow + 1);
}
else
{
offset = 1 - itemCount;
}
queryResult.SeekToOffset(SeekReference.OriginCurrent, offset);
break;
}
}
object[][] array = Utilities.FetchRowsFromQueryResult(queryResult, itemCount);
if (array.Length > 0)
{
base.StartRange = queryResult.CurrentRow - array.Length;
}
itemCount -= array.Length;
if (itemCount > 0)
{
if (array.Length == 0)
{
queryResult2.SeekToCondition(SeekReference.OriginBeginning, new ComparisonFilter(ComparisonOperator.Equal, ItemSchema.Id, storeObjectId));
switch (seekDirection)
{
case SeekDirection.Next:
if (queryResult2.EstimatedRowCount < queryResult2.CurrentRow + itemCount + 1)
{
queryResult2.SeekToOffset(SeekReference.OriginCurrent, queryResult2.EstimatedRowCount - queryResult2.CurrentRow - itemCount);
}
break;
case SeekDirection.Previous:
{
int offset2;
if (queryResult2.CurrentRow + 1 < itemCount)
{
offset2 = -1 * (queryResult2.CurrentRow + 1);
int num = itemCount - queryResult2.CurrentRow;
int estimatedRowCount = queryResult.EstimatedRowCount;
if (num > estimatedRowCount)
{
num = estimatedRowCount;
}
queryResult.SeekToOffset(SeekReference.OriginCurrent, -1 * num);
array = Utilities.FetchRowsFromQueryResult(queryResult, num);
}
else
{
offset2 = 1 - itemCount;
}
queryResult.SeekToOffset(SeekReference.OriginCurrent, offset2);
break;
}
}
}
itemsItemQuery = Utilities.FetchRowsFromQueryResult(queryResult2, itemCount);
}
this.CombineView(array, itemsItemQuery, queryResult, queryResult2);
}
}
}
}
/// <summary>
/// <paramref name="start"/>시각으로부터 <paramref name="offset"/> 만큼 떨어진 시각을 구합니다.
/// </summary>
/// <param name="start">기준 시각</param>
/// <param name="offset">기간</param>
/// <param name="seekDirection">검색 방향 (이전|이후)</param>
/// <param name="seekBoundaryMode">검색 값 포함 여부</param>
/// <returns>기준 시각으로터 오프셋만큼 떨어진 시각</returns>
protected DateTime? CalculateEnd(DateTime start, TimeSpan offset, SeekDirection seekDirection, SeekBoundaryMode seekBoundaryMode) {
if(IsDebugEnabled)
log.Debug("기준시각으로부터 오프셋만큼 떨어진 시각을 구합니다... " +
@"start=[{0}], offset=[{1}], seekDirection=[{2}], seekBoundaryMode=[{3}], Calendar=[{4}]",
start, offset, seekDirection, seekBoundaryMode, TimeCalendar);
Guard.Assert(offset >= TimeSpan.Zero, "offset 값은 TimeSpan.Zero 이상이어야 합니다. offset=[{0}]", offset);
DateTime? end = null;
DateTime moment = start;
TimeSpan? remaining = offset;
var week = new WeekRange(start, TimeCalendar);
while(week != null) {
base.IncludePeriods.Clear();
base.IncludePeriods.AddAll(GetAvailableWeekPeriods(week));
if(IsDebugEnabled)
log.Debug("가능한 기간은=[{0}]", base.IncludePeriods.CollectionToString());
end = CalculateEnd(moment, remaining.Value, seekDirection, seekBoundaryMode, out remaining);
if(end != null || remaining.HasValue == false)
break;
if(seekDirection == SeekDirection.Forward) {
week = FindNextWeek(week);
if(week != null)
moment = week.Start;
}
else {
week = FindPreviousWeek(week);
if(week != null)
moment = week.End;
}
}
if(IsDebugEnabled)
log.Debug("기준시각으로부터 오프셋만큼 떨어진 시각을 구했습니다!!! " +
@"start=[{0}], offset=[{1}], seekDirection=[{2}], seekBoundaryMode=[{3}], Calendar=[{4}], end=[{5}], remaining=[{6}]",
start, offset, seekDirection, seekBoundaryMode, TimeCalendar, end, remaining);
return end;
}
// ----------------------------------------------------------------------
protected DateTime? CalculateEnd( DateTime start, TimeSpan offset,
SeekDirection seekDirection, SeekBoundaryMode seekBoundaryMode, out TimeSpan? remaining)
{
if ( offset < TimeSpan.Zero )
{
throw new InvalidOperationException( "time span must be positive" );
}
remaining = offset;
// search periods
TimePeriodCollection searchPeriods = new TimePeriodCollection( includePeriods );
// no search periods specified: search anytime
if ( searchPeriods.Count == 0 )
{
searchPeriods.Add( TimeRange.Anytime );
}
// available periods
ITimePeriodCollection availablePeriods = new TimePeriodCollection();
// no exclude periods specified: use all search periods
if ( excludePeriods.Count == 0 )
{
availablePeriods.AddAll( searchPeriods );
}
else // remove exclude periods
{
TimeGapCalculator<TimeRange> gapCalculator = new TimeGapCalculator<TimeRange>();
foreach ( ITimePeriod searchPeriod in searchPeriods )
{
// no overlaps: use the entire search range
if ( !excludePeriods.HasOverlapPeriods( searchPeriod ) )
{
availablePeriods.Add( searchPeriod );
}
else // add gaps of search period using the exclude periods
{
availablePeriods.AddAll( gapCalculator.GetGaps( excludePeriods, searchPeriod ) );
}
}
}
// no periods available
if ( availablePeriods.Count == 0 )
{
return null;
}
// combine the available periods, ensure no overlapping
// used for FindNextPeriod/FindPreviousPeriod
if ( availablePeriods.Count > 1 )
{
TimePeriodCombiner<TimeRange> periodCombiner = new TimePeriodCombiner<TimeRange>();
availablePeriods = periodCombiner.CombinePeriods( availablePeriods );
}
// find the starting search period
ITimePeriod startPeriod = null;
DateTime seekMoment = start;
switch ( seekDirection )
{
case SeekDirection.Forward:
startPeriod = FindNextPeriod( start, availablePeriods, out seekMoment );
break;
case SeekDirection.Backward:
startPeriod = FindPreviousPeriod( start, availablePeriods, out seekMoment );
break;
}
// no starting period available
if ( startPeriod == null )
{
return null;
}
// no offset: use the search staring position
// maybe moved to the next available search period
if ( offset == TimeSpan.Zero )
{
return seekMoment;
}
// setup destination search
switch ( seekDirection )
{
case SeekDirection.Forward:
for ( int i = availablePeriods.IndexOf( startPeriod ); i < availablePeriods.Count; i++ )
{
ITimePeriod gap = availablePeriods[ i ];
TimeSpan gapRemining = gap.End - seekMoment;
bool isTargetPeriod = false;
switch ( seekBoundaryMode )
{
case SeekBoundaryMode.Fill:
isTargetPeriod = gapRemining >= remaining;
break;
case SeekBoundaryMode.Next:
isTargetPeriod = gapRemining > remaining;
break;
}
if ( isTargetPeriod )
{
DateTime end = seekMoment + remaining.Value;
remaining = null;
return end;
}
remaining = remaining - gapRemining;
if ( i == availablePeriods.Count - 1 )
{
return null;
}
seekMoment = availablePeriods[ i + 1 ].Start; // next period
}
break;
case SeekDirection.Backward:
for ( int i = availablePeriods.IndexOf( startPeriod ); i >= 0; i-- )
{
ITimePeriod gap = availablePeriods[ i ];
TimeSpan gapRemining = seekMoment - gap.Start;
bool isTargetPeriod = false;
switch ( seekBoundaryMode )
{
case SeekBoundaryMode.Fill:
isTargetPeriod = gapRemining >= remaining;
break;
case SeekBoundaryMode.Next:
isTargetPeriod = gapRemining > remaining;
break;
}
if ( isTargetPeriod )
{
DateTime end = seekMoment - remaining.Value;
remaining = null;
return end;
}
remaining = remaining - gapRemining;
if ( i == 0 )
{
return null;
}
seekMoment = availablePeriods[ i - 1 ].End; // previous period
}
break;
}
return null;
}
// ----------------------------------------------------------------------
protected DateTime? CalculateEnd( DateTime start, TimeSpan offset,
SeekDirection seekDirection, SeekBoundaryMode seekBoundaryMode )
{
if ( offset < TimeSpan.Zero )
{
throw new InvalidOperationException( "time span must be positive" );
}
DateTime? endDate = null;
DateTime moment = start;
TimeSpan? remaining = offset;
Week week = new Week( start, calendar );
// search end date, iteraring week by week
while ( week != null )
{
base.IncludePeriods.Clear();
base.IncludePeriods.AddAll( GetAvailableWeekPeriods( week ) );
endDate = CalculateEnd( moment, remaining.Value, seekDirection, seekBoundaryMode, out remaining );
if ( endDate != null || !remaining.HasValue )
{
break;
}
switch ( seekDirection )
{
case SeekDirection.Forward:
week = FindNextWeek( week );
if ( week != null )
{
moment = week.Start;
}
break;
case SeekDirection.Backward:
week = FindPreviousWeek( week );
if ( week != null )
{
moment = week.End;
}
break;
}
}
return endDate;
}
/// <summary>
/// <paramref name="start"/>시각으로부터 <paramref name="offset"/> 만큼 떨어진 시각을 구합니다.
/// </summary>
/// <param name="start">기준 시각</param>
/// <param name="offset">기간</param>
/// <param name="seekDirection">검색 방향 (이전|이후)</param>
/// <param name="seekBoundaryMode">검색 값 포함 여부</param>
/// <param name="remaining">짜투리 기간</param>
/// <returns>기준 시각으로터 오프셋만큼 떨어진 시각</returns>
protected DateTime? CalculateEnd(DateTime start, TimeSpan offset, SeekDirection seekDirection, SeekBoundaryMode seekBoundaryMode,
out TimeSpan? remaining) {
if(IsDebugEnabled)
log.Debug("기준시각으로부터 오프셋만큼 떨어진 시각을 구합니다... " +
@"start=[{0}], offset=[{1}], seekDirection=[{2}], seekBoundaryMode=[{3}]",
start, offset, seekDirection, seekBoundaryMode);
Guard.Assert(offset >= TimeSpan.Zero, "offset 값은 항상 0 이상이어야 합니다. offset=[{0}]", offset);
remaining = offset;
// search periods
ITimePeriodCollection searchPeriods = new TimePeriodCollection(IncludePeriods);
if(searchPeriods.Count == 0)
searchPeriods.Add(TimeRange.Anytime);
// available periods
ITimePeriodCollection availablePeriods = new TimePeriodCollection();
if(ExcludePeriods.Count == 0) {
availablePeriods.AddAll(searchPeriods);
}
else {
// 예외 기간을 제외합니다.
//
var gapCalculator = new TimeGapCalculator<TimeRange>();
var query
= searchPeriods
#if !SILVERLIGHT
.AsParallel()
.AsOrdered()
#endif
.SelectMany(searchPeriod =>
ExcludePeriods.HasOverlapPeriods(searchPeriod)
? gapCalculator.GetGaps(ExcludePeriods, searchPeriod) // 예외 기간과 검색 기간에서 겹치지 않는 기간을 계산하여, 추려냅니다.
: new TimePeriodCollection { searchPeriod } // 예외 기간과 겹쳐진 부분이 없다면, 기간 전체를 추가합니다.
);
availablePeriods.AddAll(query);
}
// 유효한 Period가 없다면 중단합니다.
if(availablePeriods.Count == 0)
return null;
// 기간중에 중복되는 부분의 없도록 유효한 기간을 결합합니다.
if(availablePeriods.Count > 1) {
var periodCombiner = new TimePeriodCombiner<TimeRange>();
availablePeriods = periodCombiner.CombinePeriods(availablePeriods);
}
// 첫 시작 기간을 찾습니다.
//
DateTime seekMoment;
var startPeriod = (seekDirection == SeekDirection.Forward)
? FindNextPeriod(start, availablePeriods, out seekMoment)
: FindPreviousPeriod(start, availablePeriods, out seekMoment);
// 첫 시작 기간이 없다면 중단합니다.
if(startPeriod == null)
return null;
// 오프셋 값이 0 이라면, 바로 다음 값이므로 seekMoment를 반환합니다.
if(offset == TimeSpan.Zero)
return seekMoment;
if(seekDirection == SeekDirection.Forward) {
for(var i = availablePeriods.IndexOf(startPeriod); i < availablePeriods.Count; i++) {
var gap = availablePeriods[i];
var gapRemaining = gap.End - seekMoment;
if(IsDebugEnabled)
log.Debug("Seek Forward... gap=[{0}], gapRemaining=[{1}], remaining=[{2}], seekMoment=[{3}]", gap, gapRemaining,
remaining, seekMoment);
var isTargetPeriod = (seekBoundaryMode == SeekBoundaryMode.Fill)
? gapRemaining >= remaining
: gapRemaining > remaining;
if(isTargetPeriod) {
var end = seekMoment + remaining.Value;
remaining = null;
return end;
}
remaining = remaining - gapRemaining;
if(i == availablePeriods.Count - 1)
return null;
seekMoment = availablePeriods[i + 1].Start; // next period
}
}
else {
for(var i = availablePeriods.IndexOf(startPeriod); i >= 0; i--) {
var gap = availablePeriods[i];
var gapRemaining = seekMoment - gap.Start;
if(IsDebugEnabled)
log.Debug("Seek Backward... gap=[{0}], gapRemaining=[{1}], remaining=[{2}], seekMoment=[{3}]", gap, gapRemaining,
remaining, seekMoment);
var isTargetPeriod = (seekBoundaryMode == SeekBoundaryMode.Fill)
? gapRemaining >= remaining
: gapRemaining > remaining;
if(isTargetPeriod) {
var end = seekMoment - remaining.Value;
remaining = null;
return end;
}
remaining = remaining - gapRemaining;
if(i == 0)
return null;
seekMoment = availablePeriods[i - 1].End; // previous period
}
}
return null;
}
