public IIntervalCollection <TKey, TValue> GetIntervalCollection <TKey, TValue>(string name, Mode mode)
where TKey : IComparable <TKey>
{
if (!_collectionsByName.TryGetValue(name, out var collection))
{
ThrowIfCannotCreate(name, mode);
ThrowIfNotRegistered <TKey>();
ThrowIfNotRegistered <TValue>();
IntervalCollection <TKey, TValue> .ThrowIfInvalidKey();
var tableName = AddTable(name, CollectionType.IntervalCollection, typeof(TKey), typeof(TValue));
collection = CreateIntervalCollection <TKey, TValue>(name, tableName);
AddCollection(name, collection);
}
else
{
ThrowIfMustCreate(mode);
}
EnsureTypeSafety(collection, CollectionType.IntervalCollection, typeof(TKey), typeof(TValue));
if (!(collection is IIntervalCollection <TKey, TValue> target))
{
throw new
ArgumentException(string.Format("The dictionary '{0}' has a value type of '{1}': If your intent was to create a new dictionary, you have to pick a new name!",
name,
collection.ValueType.FullName));
}
return(target);
}
public void GetBetween_PerformanceTest()
{
const int itemCount = 100000;
const int requestCount = 10000;
var random = new Random(42);
var collection = new IntervalCollection <int>();
{
int start;
int end;
for (var i = 0; i < itemCount; i++)
{
start = random.Next(1000);
end = start + random.Next(1, 50);
collection.Add(new TestInterval(start, end));
}
}
var stopwatch = Stopwatch.StartNew();
var selectedCount = 0;
for (var i = 0; i < requestCount; i++)
{
var start = random.Next(1000);
var end = start + random.Next(50);
var result = collection.GetBetween(start, end);
selectedCount += result.Count;
}
stopwatch.Stop();
Assert.Inconclusive($"Executed {nameof(collection.GetBetween)}() {requestCount} times to select {selectedCount} results from {itemCount} items in {stopwatch.Elapsed}");
}
public void TestSetUp()
{
intervalCollection = new IntervalCollection();
foreach (var interval in intervals)
{
intervalCollection.Insert(interval.Start, interval.Length);
}
}
public void GetBetween_NoItems_ReturnsEmptyCollection()
{
var collection = new IntervalCollection <int>();
var result = collection.GetBetween(0, 8);
Assert.AreEqual(0, result.Count);
}
public void PropertiesShouldBeSet()
{
int lower = 2;
int upper = 8;
var interval = new IntervalCollection<int>(lower, upper);
Assert.AreEqual(lower, interval.Lower);
Assert.AreEqual(upper, interval.Upper);
Assert.IsFalse(interval.IsLowerUnbounded);
Assert.IsFalse(interval.IsUpperUnbounded);
}
public CharacterClass(bool negate, bool ignore)
{
this.negate = negate;
this.ignore = ignore;
intervals = new IntervalCollection();
int length = 144;
pos_cats = new BitArray(length);
neg_cats = new BitArray(length);
}
public void PropertiesShouldBeSet()
{
int lower = 2;
int upper = 8;
var interval = new IntervalCollection <int>(lower, upper);
Assert.AreEqual(lower, interval.Lower);
Assert.AreEqual(upper, interval.Upper);
Assert.IsFalse(interval.IsLowerUnbounded);
Assert.IsFalse(interval.IsUpperUnbounded);
}
private void AddTempbasalToTimeline(IntervalCollection <TempBasal> timeline, TempBasal tempBasal)
{
if (tempBasal.Duration == 0)
{
timeline.Crop(tempBasal.Time);
}
else
{
timeline.Add(tempBasal.Time, tempBasal.Time.AddMinutes(tempBasal.Duration), tempBasal);
}
}
private void AddProfileToTimeline(IntervalCollection <BasalProfile> timeline, BasalProfile profile)
{
if (profile.Duration == 0)
{
timeline.Add(profile.Time, null, profile);
}
else
{
timeline.Add(profile.Time, profile.Time.AddMinutes(profile.Duration), profile);
}
}
public CharacterClass(bool negate, bool ignore)
{
this.negate = negate;
this.ignore = ignore;
intervals = new IntervalCollection();
// initialize pos/neg category arrays
int cat_size = (int)Category.LastValue;
pos_cats = new BitArray(cat_size);
neg_cats = new BitArray(cat_size);
}
public void Contains()
{
var now = DateTime.UtcNow;
var intervals = new IntervalCollection();
intervals.Add(new Interval(now, TimeSpan.FromHours(1)));
intervals.Add(new Interval(now.AddDays(10), TimeSpan.FromHours(1)));
Assert.IsTrue(intervals.Contains(now));
Assert.IsTrue(intervals.Contains(now.AddMinutes(10)));
Assert.IsFalse(intervals.Contains(now.AddMinutes(-10)));
Assert.IsFalse(intervals.Contains(now.AddDays(5)));
Assert.IsFalse(intervals.Contains(now.AddDays(11)));
}
private void AnalyzeType(TypeDefinition type)
{
foreach (var innerType in type.NestedTypes)
{
AnalyzeType(innerType);
}
// we're only interested in methods that are not abstract
foreach (var method in type.Methods.Where(x => x.HasBody))
{
var intervalCollection = new IntervalCollection();
AnalyzeBlockFrom(method, method.Body.Instructions[0], intervalCollection);
foreach (var interval in intervalCollection)
{
blocks.Add(nextBlockId++, new BlockEntry(new AssemblyEntry(method.Module.Assembly),
method.Module, method, interval.Start, interval.Length, method.MetadataToken.ToInt32()));
}
}
}
public void Intersections()
{
var now = DateTime.UtcNow;
var intervals = new IntervalCollection();
intervals.Add(new Interval(now, TimeSpan.FromHours(1)));
intervals.Add(new Interval(now.AddDays(10), TimeSpan.FromHours(1)));
Assert.IsTrue(intervals.GetIntersections().Count() == 0);
intervals.Clear();
intervals.Add(new Interval(now, TimeSpan.FromHours(2)));
intervals.Add(new Interval(now.AddHours(-0.5), TimeSpan.FromHours(1)));
var intersection = intervals.GetIntersections().Single();
Assert.AreEqual(now, intersection.Start);
Assert.AreEqual(TimeSpan.FromHours(0.5), intersection.Length);
}
public void FromUnordered_PerformanceTest()
{
const int itemCount = 100000;
var random = new Random(42);
int start;
int end;
var items = Enumerable.Range(0, itemCount).Select(i =>
{
start = random.Next(1000);
end = start + random.Next(1, 50);
return(new TestInterval(start, end));
}).ToList();
var stopwatch = Stopwatch.StartNew();
var collection = IntervalCollection <int> .FromUnordered(items);
stopwatch.Stop();
Assert.Inconclusive($"Added {itemCount} items in {stopwatch.Elapsed}");
}
public void Add_PerformanceTest()
{
const int itemCount = 100000;
var random = new Random(42);
var stopwatch = Stopwatch.StartNew();
var collection = new IntervalCollection <int>();
int start;
int end;
for (var i = 0; i < itemCount; i++)
{
start = random.Next(1000);
end = start + random.Next(1, 50);
collection.Add(new TestInterval(start, end));
}
stopwatch.Stop();
Assert.Inconclusive($"Added {itemCount} items in {stopwatch.Elapsed}");
}
public override AnchorInfo GetAnchorInfo(bool reverse)
{
int fixedWidth = base.GetFixedWidth();
ArrayList arrayList = new ArrayList();
IntervalCollection intervalCollection = new IntervalCollection();
int num = 0;
int count = base.Expressions.Count;
for (int i = 0; i < count; i++)
{
Expression expression;
if (reverse)
{
expression = base.Expressions[count - i - 1];
}
else
{
expression = base.Expressions[i];
}
AnchorInfo anchorInfo = expression.GetAnchorInfo(reverse);
arrayList.Add(anchorInfo);
if (anchorInfo.IsPosition)
{
return(new AnchorInfo(this, num + anchorInfo.Offset, fixedWidth, anchorInfo.Position));
}
if (anchorInfo.IsSubstring)
{
intervalCollection.Add(anchorInfo.GetInterval(num));
}
if (anchorInfo.IsUnknownWidth)
{
break;
}
num += anchorInfo.Width;
}
intervalCollection.Normalize();
Interval interval = Interval.Empty;
foreach (object obj in intervalCollection)
{
Interval interval2 = (Interval)obj;
if (interval2.Size > interval.Size)
{
interval = interval2;
}
}
if (interval.IsEmpty)
{
return(new AnchorInfo(this, fixedWidth));
}
bool flag = false;
int num2 = 0;
num = 0;
for (int j = 0; j < arrayList.Count; j++)
{
AnchorInfo anchorInfo2 = (AnchorInfo)arrayList[j];
if (anchorInfo2.IsSubstring && interval.Contains(anchorInfo2.GetInterval(num)))
{
flag |= anchorInfo2.IgnoreCase;
arrayList[num2++] = anchorInfo2;
}
if (anchorInfo2.IsUnknownWidth)
{
break;
}
num += anchorInfo2.Width;
}
StringBuilder stringBuilder = new StringBuilder();
for (int k = 0; k < num2; k++)
{
AnchorInfo anchorInfo3;
if (reverse)
{
anchorInfo3 = (AnchorInfo)arrayList[num2 - k - 1];
}
else
{
anchorInfo3 = (AnchorInfo)arrayList[k];
}
stringBuilder.Append(anchorInfo3.Substring);
}
if (stringBuilder.Length == interval.Size)
{
return(new AnchorInfo(this, interval.low, fixedWidth, stringBuilder.ToString(), flag));
}
if (stringBuilder.Length > interval.Size)
{
Console.Error.WriteLine("overlapping?");
return(new AnchorInfo(this, fixedWidth));
}
throw new SystemException("Shouldn't happen");
}
public override AnchorInfo GetAnchorInfo(bool reverse)
{
int ptr;
int width = GetFixedWidth();
ArrayList infos = new ArrayList();
IntervalCollection segments = new IntervalCollection();
// accumulate segments
ptr = 0;
int count = Expressions.Count;
for (int i = 0; i < count; ++i)
{
Expression e;
if (reverse)
{
e = Expressions [count - i - 1];
}
else
{
e = Expressions [i];
}
AnchorInfo info = e.GetAnchorInfo(reverse);
infos.Add(info);
if (info.IsPosition)
{
return(new AnchorInfo(this, ptr + info.Offset, width, info.Position));
}
if (info.IsSubstring)
{
segments.Add(info.GetInterval(ptr));
}
if (info.IsUnknownWidth)
{
break;
}
ptr += info.Width;
}
// normalize and find the longest segment
segments.Normalize();
Interval longest = Interval.Empty;
foreach (Interval segment in segments)
{
if (segment.Size > longest.Size)
{
longest = segment;
}
}
if (longest.IsEmpty)
{
return(new AnchorInfo(this, width));
}
// now chain the substrings that made this segment together
bool ignore = false;
int n_strings = 0;
ptr = 0;
for (int i = 0; i < infos.Count; ++i)
{
AnchorInfo info = (AnchorInfo)infos [i];
if (info.IsSubstring && longest.Contains(info.GetInterval(ptr)))
{
ignore |= info.IgnoreCase;
infos [n_strings++] = info;
}
if (info.IsUnknownWidth)
{
break;
}
ptr += info.Width;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n_strings; ++i)
{
AnchorInfo info;
if (reverse)
{
info = (AnchorInfo)infos [n_strings - i - 1];
}
else
{
info = (AnchorInfo)infos [i];
}
sb.Append(info.Substring);
}
if (sb.Length == longest.Size)
{
return(new AnchorInfo(this, longest.low, width, sb.ToString(), ignore));
}
// were the string segments overlapping?
if (sb.Length > longest.Size)
{
Console.Error.WriteLine("overlapping?");
return(new AnchorInfo(this, width));
}
throw new SystemException("Shouldn't happen");
}
public override void Compile(ICompiler cmp, bool reverse)
{
// create the meta-collection
IntervalCollection meta =
intervals.GetMetaCollection(new IntervalCollection.CostDelegate(GetIntervalCost));
// count ops
int count = meta.Count;
for (int i = 0; i < pos_cats.Length; ++i)
{
if (pos_cats[i] || neg_cats [i])
{
++count;
}
}
if (count == 0)
{
return;
}
// emit in op for |meta| > 1
LinkRef tail = cmp.NewLink();
if (count > 1)
{
cmp.EmitIn(tail);
}
// emit character/range/sets from meta-collection
// we emit these first so that any 'ignore' flags will be noticed by the evaluator
foreach (Interval a in meta)
{
if (a.IsDiscontiguous) // Set
{
BitArray bits = new BitArray(a.Size);
foreach (Interval b in intervals)
{
if (a.Contains(b))
{
for (int i = b.low; i <= b.high; ++i)
{
bits[i - a.low] = true;
}
}
}
cmp.EmitSet((char)a.low, bits, negate, ignore, reverse);
}
else if (a.IsSingleton) // Character
{
cmp.EmitCharacter((char)a.low, negate, ignore, reverse);
}
else // Range
{
cmp.EmitRange((char)a.low, (char)a.high, negate, ignore, reverse);
}
}
// emit categories
for (int i = 0; i < pos_cats.Length; ++i)
{
if (pos_cats[i])
{
if (neg_cats [i])
{
cmp.EmitCategory(Category.AnySingleline, negate, reverse);
}
else
{
cmp.EmitCategory((Category)i, negate, reverse);
}
}
else if (neg_cats[i])
{
cmp.EmitNotCategory((Category)i, negate, reverse);
}
}
// finish up
if (count > 1)
{
if (negate)
{
cmp.EmitTrue();
}
else
{
cmp.EmitFalse();
}
cmp.ResolveLink(tail);
}
}
public CharacterClass (bool negate, bool ignore) {
this.negate = negate;
this.ignore = ignore;
intervals = new IntervalCollection ();
// initialize pos/neg category arrays
int cat_size = (int) Category.LastValue;
pos_cats = new BitArray (cat_size);
neg_cats = new BitArray (cat_size);
}
public override AnchorInfo GetAnchorInfo (bool reverse)
{
int ptr;
int width = GetFixedWidth ();
ArrayList infos = new ArrayList ();
IntervalCollection segments = new IntervalCollection ();
// accumulate segments
ptr = 0;
int count = Expressions.Count;
for (int i = 0; i < count; ++ i) {
Expression e;
if (reverse)
e = Expressions [count - i - 1];
else
e = Expressions [i];
AnchorInfo info = e.GetAnchorInfo (reverse);
infos.Add (info);
if (info.IsPosition)
return new AnchorInfo (this, ptr + info.Offset, width, info.Position);
if (info.IsSubstring)
segments.Add (info.GetInterval (ptr));
if (info.IsUnknownWidth)
break;
ptr += info.Width;
}
// normalize and find the longest segment
segments.Normalize ();
Interval longest = Interval.Empty;
foreach (Interval segment in segments) {
if (segment.Size > longest.Size)
longest = segment;
}
if (longest.IsEmpty)
return new AnchorInfo (this, width);
// now chain the substrings that made this segment together
bool ignore = false;
int n_strings = 0;
ptr = 0;
for (int i = 0; i < infos.Count; ++i) {
AnchorInfo info = (AnchorInfo) infos [i];
if (info.IsSubstring && longest.Contains (info.GetInterval (ptr))) {
ignore |= info.IgnoreCase;
infos [n_strings ++] = info;
}
if (info.IsUnknownWidth)
break;
ptr += info.Width;
}
StringBuilder sb = new StringBuilder ();
for (int i = 0; i < n_strings; ++i) {
AnchorInfo info;
if (reverse)
info = (AnchorInfo) infos [n_strings - i - 1];
else
info = (AnchorInfo) infos [i];
sb.Append (info.Substring);
}
if (sb.Length == longest.Size)
return new AnchorInfo (this, longest.low, width, sb.ToString (), ignore);
// were the string segments overlapping?
if (sb.Length > longest.Size) {
Console.Error.WriteLine ("overlapping?");
return new AnchorInfo (this, width);
}
throw new SystemException ("Shouldn't happen");
}
public override AnchorInfo GetAnchorInfo(bool reverse)
{
int ptr;
int width = GetFixedWidth();
ArrayList infos = new ArrayList();
IntervalCollection segments = new IntervalCollection();
// accumulate segments
ptr = 0;
//foreach (Expression e in Expressions) {
int count = Expressions.Count;
for (int i = 0; i < count; ++i)
{
Expression e;
if (reverse)
{
e = Expressions [count - i - 1];
}
else
{
e = Expressions [i];
}
AnchorInfo info = e.GetAnchorInfo(reverse);
infos.Add(info);
if (info.IsPosition)
{
return(new AnchorInfo(this, ptr + info.Offset, width, info.Position));
}
if (info.IsSubstring)
{
segments.Add(info.GetInterval(ptr));
}
if (info.IsUnknownWidth)
{
break;
}
ptr += info.Width;
}
// normalize and find the longest segment
segments.Normalize();
Interval longest = Interval.Empty;
foreach (Interval segment in segments)
{
if (segment.Size > longest.Size)
{
longest = segment;
}
}
// now chain the substrings that made this segment together
if (!longest.IsEmpty)
{
string str = "";
ArrayList strs = new ArrayList();
bool ignore = false;
ptr = 0;
//foreach (AnchorInfo info in infos) {
for (int i = 0; i < infos.Count; ++i)
{
AnchorInfo info;
info = (AnchorInfo)infos[i];
if (info.IsSubstring && longest.Contains(info.GetInterval(ptr)))
{
//str += info.Substring; // TODO mark subexpressions
strs.Add(info.Substring);
ignore |= info.IgnoreCase;
}
if (info.IsUnknownWidth)
{
break;
}
ptr += info.Width;
}
for (int i = 0; i < strs.Count; ++i)
{
if (reverse)
{
str += strs [strs.Count - i - 1];
}
else
{
str += strs [i];
}
}
return(new AnchorInfo(this, longest.low, width, str, ignore));
}
return(new AnchorInfo(this, width));
}
public override void Compile(ICompiler cmp, bool reverse)
{
// create the meta-collection
IntervalCollection meta =
intervals.GetMetaCollection(new IntervalCollection.CostDelegate(GetIntervalCost));
// count ops
int count = meta.Count;
for (int i = 0; i < pos_cats.Length; ++i)
{
// use BitArray.Get instead of indexer for speedups
//if (pos_cats[i]) ++ count;
//if (neg_cats[i]) ++ count;
if (pos_cats.Get(i))
{
++count;
}
if (neg_cats.Get(i))
{
++count;
}
}
if (count == 0)
{
return;
}
// emit in op for |meta| > 1
LinkRef tail = cmp.NewLink();
if (count > 1)
{
cmp.EmitIn(tail);
}
// emit categories
for (int i = 0; i < pos_cats.Length; ++i)
{
// use BitArray.Get instead of indexer for speedups
//if (pos_cats[i]) {
if (pos_cats.Get(i))
{
//if (neg_cats [i])
if (neg_cats.Get(i))
{
cmp.EmitCategory(Category.AnySingleline, negate, reverse);
}
else
{
cmp.EmitCategory((Category)i, negate, reverse);
}
// } else if (neg_cats[i]) {
}
else if (neg_cats.Get(i))
{
cmp.EmitCategory((Category)i, !negate, reverse);
}
}
// emit character/range/sets from meta-collection
foreach (Interval a in meta)
{
if (a.IsDiscontiguous) // Set
{
BitArray bits = new BitArray(a.Size);
foreach (Interval b in intervals)
{
if (a.Contains(b))
{
for (int i = b.low; i <= b.high; ++i)
{
// use BitArray.Get instead of indexer for speedups : bits[i - a.low] = true;
bits.Set(i - a.low, true);
}
}
}
cmp.EmitSet((char)a.low, bits, negate, ignore, reverse);
}
else if (a.IsSingleton) // Character
{
cmp.EmitCharacter((char)a.low, negate, ignore, reverse);
}
else // Range
{
cmp.EmitRange((char)a.low, (char)a.high, negate, ignore, reverse);
}
}
// finish up
if (count > 1)
{
if (negate)
{
cmp.EmitTrue();
}
else
{
cmp.EmitFalse();
}
cmp.ResolveLink(tail);
}
}
public override void Compile(ICompiler cmp, bool reverse)
{
IntervalCollection metaCollection = intervals.GetMetaCollection(GetIntervalCost);
int num = metaCollection.Count;
for (int i = 0; i < pos_cats.Length; i++)
{
if (pos_cats[i] || neg_cats[i])
{
num++;
}
}
if (num == 0)
{
return;
}
LinkRef linkRef = cmp.NewLink();
if (num > 1)
{
cmp.EmitIn(linkRef);
}
foreach (Interval item in metaCollection)
{
Interval interval = item;
if (interval.IsDiscontiguous)
{
BitArray bitArray = new BitArray(interval.Size);
foreach (Interval interval2 in intervals)
{
Interval i2 = interval2;
if (interval.Contains(i2))
{
for (int j = i2.low; j <= i2.high; j++)
{
bitArray[j - interval.low] = true;
}
}
}
cmp.EmitSet((char)interval.low, bitArray, negate, ignore, reverse);
}
else if (interval.IsSingleton)
{
cmp.EmitCharacter((char)interval.low, negate, ignore, reverse);
}
else
{
cmp.EmitRange((char)interval.low, (char)interval.high, negate, ignore, reverse);
}
}
for (int k = 0; k < pos_cats.Length; k++)
{
if (pos_cats[k])
{
if (neg_cats[k])
{
cmp.EmitCategory(Category.AnySingleline, negate, reverse);
}
else
{
cmp.EmitCategory((Category)k, negate, reverse);
}
}
else if (neg_cats[k])
{
cmp.EmitNotCategory((Category)k, negate, reverse);
}
}
if (num > 1)
{
if (negate)
{
cmp.EmitTrue();
}
else
{
cmp.EmitFalse();
}
cmp.ResolveLink(linkRef);
}
}
public async IAsyncEnumerable <TimeValue> BasalRates(DateTimeOffset start, DateTimeOffset end)
{
using var nsql = await NightSql.GetInstance(Configuration);
var zeroBasalSchedule = (UtcOffset : 0, Rates : new double[48]);
var basalTimeline = new IntervalCollection <BasalProfile>();
var tempBasalTimeline = new IntervalCollection <TempBasal>();
var bpStart = start;
var sql = "SELECT * FROM basal WHERE duration = 0 AND time <= @t1 ORDER BY time DESC LIMIT 1";
await foreach (var bpr in nsql.ExecuteQuery(sql, new [] { nsql.GetParameter("t1", start) }))
{
var earlyProfile = await ReadProfile(bpr);
AddProfileToTimeline(basalTimeline, earlyProfile);
bpStart = earlyProfile.Time;
}
sql = "SELECT * FROM basal WHERE time > @t1 AND time < @t2 ORDER BY time";
await foreach (var bpr in nsql.ExecuteQuery(sql, new [] { nsql.GetParameter("t1", bpStart), nsql.GetParameter("t2", end) }))
{
var profile = await ReadProfile(bpr);
AddProfileToTimeline(basalTimeline, profile);
}
sql = "SELECT * FROM tempbasal WHERE time <= @t1 ORDER BY time DESC LIMIT 1";
await foreach (var tbr in nsql.ExecuteQuery(sql, new [] { nsql.GetParameter("t1", start) }))
{
var earlyTempBasal = await ReadTempBasal(tbr);
AddTempbasalToTimeline(tempBasalTimeline, earlyTempBasal);
}
sql = "SELECT * FROM tempbasal WHERE time > @t1 AND time < @t2 ORDER BY time";
await foreach (var tbr in nsql.ExecuteQuery(sql, new [] { nsql.GetParameter("t1", start), nsql.GetParameter("t2", end) }))
{
AddTempbasalToTimeline(tempBasalTimeline, await ReadTempBasal(tbr));
}
var pointOfInterest = start;
double?lastRate = null;
var activeBasalRates = new double[48];
var activeUtcOffset = 0;
while (pointOfInterest < end)
{
var activeBasalInterval = basalTimeline[pointOfInterest];
var activeBasal = activeBasalInterval?.Value;
var activeTempBasalInterval = tempBasalTimeline[pointOfInterest];
var activeTempBasal = activeTempBasalInterval?.Value;
if (activeBasal.HasValue)
{
for (int i = 0; i < 48; i++)
{
activeBasalRates[i] = activeBasal.Value.BasalRates[i];
}
activeUtcOffset = activeBasal.Value.UtcOffsetInMinutes;
}
if (activeTempBasal.HasValue)
{
if (activeTempBasal.Value.AbsoluteRate.HasValue)
{
for (int i = 0; i < 48; i++)
{
activeBasalRates[i] = activeTempBasal.Value.AbsoluteRate.Value;
}
}
else if (activeTempBasal.Value.Percentage.HasValue)
{
for (int i = 0; i < 48; i++)
{
activeBasalRates[i] *= activeTempBasal.Value.Percentage.Value;
activeBasalRates[i] /= 100;
}
}
}
var scheduleOffset = pointOfInterest.AddMinutes(activeUtcOffset);
var scheduleIndex = scheduleOffset.Hour * 2;
if (scheduleOffset.Minute > 30)
{
scheduleIndex++;
}
var scheduledRate = activeBasalRates[scheduleIndex];
if (lastRate != scheduledRate)
{
yield return(new TimeValue
{
Time = pointOfInterest,
Value = scheduledRate
});
lastRate = scheduledRate;
}
pointOfInterest = GetNextHalfHourMark(pointOfInterest);
if (activeBasalInterval?.End < pointOfInterest)
{
pointOfInterest = activeBasalInterval.End;
}
if (activeTempBasalInterval?.End < pointOfInterest)
{
pointOfInterest = activeTempBasalInterval.End;
}
}
}
private void AnalyzeBlockFrom(MethodDefinition method, Instruction instruction, IntervalCollection methodBlocks)
{
int nextIntervalStart;
var startingOffset = instruction.Offset;
// if our entry point can be found in some existing block
// we have to divide that block
if (methodBlocks.DivideIfNecessary(startingOffset, out nextIntervalStart))
{
return;
}
if (nextIntervalStart == -1)
{
nextIntervalStart = int.MaxValue;
}
while (NextInstructionShouldBeReached(instruction) &&
(instruction.Offset + instruction.GetSize()) < nextIntervalStart)
{
instruction = instruction.Next;
if (instruction == null)
{
throw new InvalidOperationException("Invalid IL code.");
}
}
var instructionSize = instruction.GetSize();
methodBlocks.Insert(startingOffset, instruction.Offset - startingOffset + instructionSize);
switch (instruction.OpCode.FlowControl)
{
case FlowControl.Return:
case FlowControl.Throw:
return;
case FlowControl.Branch:
AnalyzeBlockFrom(method, ((Instruction)instruction.Operand), methodBlocks);
break;
case FlowControl.Cond_Branch:
var operandAsInstruction = instruction.Operand as Instruction;
var operandAsInstructionArray = instruction.Operand as Instruction[];
if (operandAsInstruction != null)
{
AnalyzeBlockFrom(method, operandAsInstruction, methodBlocks);
}
else if (operandAsInstructionArray != null)
{
foreach (var operandInstruction in operandAsInstructionArray)
{
AnalyzeBlockFrom(method, operandInstruction, methodBlocks);
}
}
AnalyzeBlockFrom(method, instruction.Next, methodBlocks);
break;
case FlowControl.Break:
case FlowControl.Meta:
case FlowControl.Phi:
throw new NotImplementedException();
case FlowControl.Call:
case FlowControl.Next:
// we've reached here due to the nextIntervalStart that finished our scan prematurely
return;
}
}
public override AnchorInfo GetAnchorInfo (bool reverse) {
int ptr;
int width = GetFixedWidth ();
ArrayList infos = new ArrayList ();
IntervalCollection segments = new IntervalCollection ();
// accumulate segments
ptr = 0;
//foreach (Expression e in Expressions) {
int count = Expressions.Count;
for (int i = 0; i < count; ++ i) {
Expression e;
if (reverse)
e = Expressions [count - i - 1];
else
e = Expressions [i];
AnchorInfo info = e.GetAnchorInfo (reverse);
infos.Add (info);
if (info.IsPosition)
return new AnchorInfo (this, ptr + info.Offset, width, info.Position);
if (info.IsSubstring)
segments.Add (info.GetInterval (ptr));
if (info.IsUnknownWidth)
break;
ptr += info.Width;
}
// normalize and find the longest segment
segments.Normalize ();
Interval longest = Interval.Empty;
foreach (Interval segment in segments) {
if (segment.Size > longest.Size)
longest = segment;
}
// now chain the substrings that made this segment together
if (!longest.IsEmpty) {
string str = "";
ArrayList strs = new ArrayList();
bool ignore = false;
ptr = 0;
//foreach (AnchorInfo info in infos) {
for (int i = 0; i < infos.Count; ++ i) {
AnchorInfo info;
info = (AnchorInfo)infos[i];
if (info.IsSubstring && longest.Contains (info.GetInterval (ptr))) {
//str += info.Substring; // TODO mark subexpressions
strs.Add(info.Substring);
ignore |= info.IgnoreCase;
}
if (info.IsUnknownWidth)
break;
ptr += info.Width;
}
for (int i = 0; i< strs.Count; ++i)
{
if (reverse)
str += strs [strs.Count - i - 1];
else
str += strs [i];
}
return new AnchorInfo (this, longest.low, width, str, ignore);
}
return new AnchorInfo (this, width);
}
