public void ToDateTimeOffset()
{
var plusOne = new TimeSpan(1, 0, 0);
var plusTwo = new TimeSpan(2, 0, 0);
var pt = PartialTime.Parse("13:45:56");
var dto = pt.ToDateTimeOffset(2019, 7, 23, plusOne);
Assert.AreEqual(2019, dto.Year);
Assert.AreEqual(7, dto.Month);
Assert.AreEqual(23, dto.Day);
Assert.AreEqual(13, dto.Hour);
Assert.AreEqual(45, dto.Minute);
Assert.AreEqual(56, dto.Second);
Assert.AreEqual(plusOne, dto.Offset);
pt = PartialTime.Parse("13:45:56.456+02:00");
dto = pt.ToDateTimeOffset(2019, 7, 23, plusOne);
Assert.AreEqual(13, dto.Hour);
Assert.AreEqual(45, dto.Minute);
Assert.AreEqual(56, dto.Second);
Assert.AreEqual(456, dto.Millisecond);
Assert.AreEqual(plusTwo, dto.Offset);
pt = PartialTime.Parse("13+02:00");
dto = pt.ToDateTimeOffset(2019, 7, 23, plusOne);
Assert.AreEqual(13, dto.Hour);
Assert.AreEqual(0, dto.Minute);
Assert.AreEqual(0, dto.Second);
Assert.AreEqual(plusTwo, dto.Offset);
}
private static string convertToXmlString(object value)
{
return(value switch
{
bool bl => XmlConvert.ToString(bl),
Byte by => XmlConvert.ToString(by), // Not used in FHIR serialization
Char cr => XmlConvert.ToString(cr), // Not used in FHIR serialization
DateTime dt => XmlConvert.ToString(dt, FMT_FULL), // Obsolete: use DateTimeOffset instead!!
decimal dec => XmlConvert.ToString(dec),
Double dbl => XmlConvert.ToString(dbl),
Int16 i16 => XmlConvert.ToString(i16),
Int32 i32 => XmlConvert.ToString(i32),
Int64 i64 => XmlConvert.ToString(i64), // Not used in FHIR serialization
SByte sb => XmlConvert.ToString(sb), // Not used in FHIR serialization
Single sing => XmlConvert.ToString(sing), // Not used in FHIR serialization
UInt16 uint16 => XmlConvert.ToString(uint16), // Not used in FHIR serialization
UInt32 uint32 => XmlConvert.ToString(uint32), // Not used in FHIR serialization
UInt64 uint64 => XmlConvert.ToString(uint64), // Not used in FHIR serialization
byte[] barr => System.Convert.ToBase64String(barr),
DateTimeOffset dto => XmlConvert.ToString(dto, FMT_FULL),
Uri uri => uri.ToString(),
PartialDateTime pdt => pdt.ToString(),
PartialTime pt => pt.ToString(),
PartialDate pd => pd.ToString(),
Enum en => en.GetLiteral(),
BigInteger bi => bi.ToString(),
Quantity q => q.ToString(),
_ => throw Error.NotSupported($"Cannot convert '{value.GetType().Name}' value '{value}' to string"),
});
/// <summary>
/// FhirPath toTime() function.
/// </summary>
/// <param name="focus"></param>
/// <returns></returns>
public static PartialTime?ToTime(this ITypedElement focus)
{
var val = focus?.Value;
if (val == null)
{
return(null);
}
switch (val)
{
case PartialTime pt:
return(pt);
case string s:
return(convertString(s));
default:
return(null);
}
PartialTime?convertString(string si)
{
// Inconsistenty, the format for a time requires the 'T' prefix, while
// convertsToDateTime() does not expect a '@'.
if (!si.StartsWith("T"))
{
return(null);
}
return(PartialTime.TryParse(si.Substring(1), out var result) ?
result : (PartialTime?)null);
}
}
public void FromDateTimeOffset()
{
var plusOne = new TimeSpan(1, 0, 0);
var dto = new DateTimeOffset(2019, 7, 23, 13, 45, 56, 567, plusOne);
var pt = PartialTime.FromDateTimeOffset(dto);
Assert.AreEqual(13, pt.Hours);
Assert.AreEqual(45, pt.Minutes);
Assert.AreEqual(56, pt.Seconds);
Assert.AreEqual(567, pt.Millis);
Assert.IsNull(pt.Offset);
pt = PartialTime.FromDateTimeOffset(dto, includeOffset: true);
Assert.AreEqual(13, pt.Hours);
Assert.AreEqual(45, pt.Minutes);
Assert.AreEqual(56, pt.Seconds);
Assert.AreEqual(567, pt.Millis);
Assert.AreEqual(plusOne, pt.Offset);
pt = PartialTime.FromDateTimeOffset(dto, prec: PartialPrecision.Hour, includeOffset: true);
Assert.AreEqual(13, pt.Hours);
Assert.IsNull(pt.Minutes);
Assert.AreEqual(PartialPrecision.Hour, pt.Precision);
}
public void TimeComparison()
{
Assert.IsTrue(PartialTime.Parse("13:00:00Z") > PartialTime.Parse("12:00:00Z"));
Assert.IsTrue(PartialTime.Parse("13:00:00Z") < PartialTime.Parse("18:00:00+02:00"));
Assert.IsTrue(PartialTime.Parse("12:34:00+00:00") > PartialTime.Parse("12:33:55+00:00"));
Assert.IsTrue(PartialTime.Parse("13:00:00+00:00") < PartialTime.Parse("15:01:00+02:00"));
Assert.IsTrue(PartialTime.Parse("13:00:00+00:00") > PartialTime.Parse("14:59:00+02:00"));
}
public void CheckOrdering()
{
Assert.AreEqual(1, PartialTime.Parse("13:00:00Z").CompareTo(PartialTime.Parse("12:00:00Z")));
Assert.AreEqual(-1, PartialTime.Parse("13:00:00Z").CompareTo(PartialTime.Parse("18:00:00+02:00")));
Assert.AreEqual(1, PartialTime.Parse("12:34:00+00:00").CompareTo(PartialTime.Parse("12:33:55+00:00")));
Assert.AreEqual(-1, PartialTime.Parse("13:00:00+00:00").CompareTo(PartialTime.Parse("15:01:00+02:00")));
Assert.AreEqual(0, PartialTime.Parse("13:45:02+01:00").CompareTo(PartialTime.Parse("13:45:02+01:00")));
}
public void TimeComparison()
{
Assert.True(PartialDateTime.Parse("2012-03-04T13:00:00Z") > PartialDateTime.Parse("2012-03-04T12:00:00Z"));
Assert.True(PartialDateTime.Parse("2012-03-04T13:00:00Z") < PartialDateTime.Parse("2012-03-04T18:00:00+02:00"));
Assert.True(PartialTime.Parse("12:34:00+00:00") > PartialTime.Parse("12:33:55+00:00"));
Assert.True(PartialTime.Parse("13:00:00+00:00") < PartialTime.Parse("15:01:00+02:00"));
Assert.True(PartialTime.Parse("13:00:00+00:00") > PartialTime.Parse("14:59:00+02:00"));
}
public void CheckOrdering()
{
Assert.Equal(1, PartialDateTime.Parse("2012-03-04T13:00:00Z").CompareTo(PartialDateTime.Parse("2012-03-04T12:00:00Z")));
Assert.Equal(-1, PartialDateTime.Parse("2012-03-04T13:00:00Z").CompareTo(PartialDateTime.Parse("2012-03-04T18:00:00+02:00")));
Assert.Equal(0, PartialDateTime.Parse("2015-01-01").CompareTo(PartialDateTime.Parse("2015-01-01")));
Assert.Equal(1, PartialTime.Parse("12:34:00+00:00").CompareTo(PartialTime.Parse("12:33:55+00:00")));
Assert.Equal(-1, PartialTime.Parse("13:00:00+00:00").CompareTo(PartialTime.Parse("15:01:00+02:00")));
Assert.Equal(0, PartialTime.Parse("13:45:02+01:00").CompareTo(PartialTime.Parse("13:45:02+01:00")));
}
public void ConvertToString()
{
var inputs = ElementNode.CreateList("hoi", 4L, 3.4m, true, false, PartialTime.Parse("15:47:00+01:00"),
PartialDateTime.Parse("2019-01-11T15:47:00+01:00"));
var vals = new[] { "hoi", "4", "3.4", "true", "false", "15:47:00+01:00", "2019-01-11T15:47:00+01:00" };
inputs.Zip(vals, (i, v) => (i, v))
.ToList()
.ForEach(c => Assert.AreEqual(c.v, c.i.ToString()));
inputs.ToList().ForEach(c => Assert.IsTrue(c.ConvertsToString()));
}
public void TimeConstructor()
{
PartialTime.Parse("12:34:44+02:00");
PartialTime.Parse("12:34:44");
PartialTime.Parse("12:34:44Z");
Assert.True(PartialTime.TryParse("12:34:44Z", out PartialTime pd));
Assert.Equal(pd, PartialTime.Parse("12:34:44Z"));
Assert.Equal("12:34:44Z", pd.ToString());
Assert.False(PartialTime.TryParse("92:34:44Z", out pd));
}
public override void Draw(IDrawingToolkit tk, Area area)
{
if (!UpdateDrawArea(tk, area, Area))
{
return;
}
base.Draw(tk, area);
tk.Begin();
cancelRect = new Rectangle(
new Point((Position.X + Width) - StyleConf.ButtonRecWidth, Position.Y),
StyleConf.ButtonRecWidth, HeaderHeight);
if (Active && Mode != DashboardMode.Edit)
{
tk.LineWidth = StyleConf.ButtonLineWidth;
tk.StrokeColor = Button.BackgroundColor;
tk.FillColor = Button.BackgroundColor;
tk.FontWeight = FontWeight.Normal;
tk.FontSize = StyleConf.ButtonHeaderFontSize;
tk.FontAlignment = FontAlignment.Left;
tk.DrawText(new Point(Position.X + TextHeaderX, Position.Y),
Button.Width - TextHeaderX, iconImage.Height, Button.Timer.Name);
tk.FontWeight = FontWeight.Bold;
tk.FontSize = StyleConf.ButtonTimerFontSize;
tk.FontAlignment = FontAlignment.Center;
tk.DrawText(new Point(Position.X, Position.Y + iconImage.Height),
Button.Width, Button.Height - iconImage.Height,
PartialTime.ToSecondsString(), false, true);
tk.FillColor = tk.StrokeColor = BackgroundColor;
tk.DrawRectangle(cancelRect.TopLeft, cancelRect.Width, cancelRect.Height);
tk.StrokeColor = TextColor;
tk.FillColor = TextColor;
tk.DrawImage(new Point(cancelRect.TopLeft.X, cancelRect.TopLeft.Y + 5),
cancelRect.Width, cancelRect.Height - 10, cancelImage, true, true);
}
else
{
Text = Button.Name;
DrawText(tk);
Text = null;
}
if (TeamImage != null)
{
tk.DrawImage(new Point(Position.X + Width - 40, Position.Y + 5), 40,
iconImage.Height, TeamImage, true);
}
tk.End();
}
public void TimeEquality()
{
Assert.True(PartialDateTime.Parse("2015-01-01") == PartialDateTime.Parse("2015-01-01"));
Assert.True(PartialDateTime.Parse("2015-01-01") != PartialDateTime.Parse("2015-01"));
Assert.True(PartialDateTime.Parse("2015-01-01T13:40:50+02:00") == PartialDateTime.Parse("2015-01-01T13:40:50+02:00"));
Assert.True(PartialDateTime.Parse("2015-01-01T13:40:50+00:00") == PartialDateTime.Parse("2015-01-01T13:40:50Z"));
Assert.True(PartialDateTime.Parse("2015-01-01T13:40:50+00:10") != PartialDateTime.Parse("2015-01-01T13:40:50Z"));
Assert.True(PartialDateTime.Parse("2015-01-01T13:40:50+00:10") != PartialDateTime.Parse("2015-01-01"));
Assert.True(PartialTime.Parse("13:45:02Z") == PartialTime.Parse("13:45:02+00:00"));
Assert.True(PartialTime.Parse("13:45:02+01:00") == PartialTime.Parse("13:45:02+01:00"));
Assert.True(PartialTime.Parse("13:45:02+00:00") != PartialTime.Parse("13:45:02+01:00"));
}
public void GetNow()
{
var now = PartialTime.Now();
var now2 = DateTimeOffset.Now;
Assert.AreEqual(now2.Hour, now.Hours);
Assert.AreEqual(now2.Minute, now.Minutes);
// Assert.AreEqual(now2.Second, now.Seconds); // well, maybe not to avoid random CI build/test failures
Assert.AreEqual(PartialPrecision.Fraction, now.Precision);
Assert.IsFalse(now.HasOffset);
now = PartialTime.Now(includeOffset: true);
Assert.IsTrue(now.HasOffset);
}
public void FhirPath_Gramm_Literal()
{
var parser = Grammar.Literal.End();
AssertParser.SucceedsMatch(parser, "'hi there'", new ConstantExpression("hi there"));
AssertParser.SucceedsMatch(parser, "3", new ConstantExpression(3L));
AssertParser.SucceedsMatch(parser, "3.14", new ConstantExpression(3.14m));
AssertParser.SucceedsMatch(parser, "@2013-12", new ConstantExpression(PartialDateTime.Parse("2013-12")));
AssertParser.SucceedsMatch(parser, "@T12:23:34Z", new ConstantExpression(PartialTime.Parse("12:23:34Z")));
AssertParser.SucceedsMatch(parser, "true", new ConstantExpression(true));
AssertParser.SucceedsMatch(parser, "@2014-12-13T12:00:00+02:00", new ConstantExpression(PartialDateTime.Parse("2014-12-13T12:00:00+02:00")));
AssertParser.FailsMatch(parser, "%constant");
AssertParser.FailsMatch(parser, "\"quotedstring\"");
AssertParser.FailsMatch(parser, "A23identifier");
}
public void ConvertToDateTime()
{
var now = PartialDateTime.Parse("2019-01-11T15:47:00+01:00");
var inputs = ElementNode.CreateList(new DateTimeOffset(2019, 1, 11, 15, 47, 00, new TimeSpan(1, 0, 0)),
"2019-01", "2019-01-11T15:47:00+01:00");
var vals = new[] { now, PartialDateTime.Parse("2019-01"), now };
inputs.Zip(vals, (i, v) => (i, v))
.ToList()
.ForEach(c => Assert.AreEqual(c.i.ToDateTime(), c.v));
inputs.ToList().ForEach(c => Assert.IsTrue(c.ConvertsToDateTime()));
var wrong = ElementNode.CreateList("hi", 2.6m, false, PartialTime.Parse("16:05:49")).ToList();
wrong.ForEach(c => Assert.IsNull(c.ToDateTime()));
wrong.ForEach(c => Assert.IsFalse(c.ConvertsToDateTime()));
}
public void TimeConstructor()
{
accept("12:34:44.123456+02:00", 12, 34, 44, 123, new TimeSpan(2, 0, 0));
accept("12:34:44.1+02:00", 12, 34, 44, 100, new TimeSpan(2, 0, 0));
accept("12:34:44+02:00", 12, 34, 44, null, new TimeSpan(2, 0, 0));
accept("12:34:44Z", 12, 34, 44, null, TimeSpan.Zero);
accept("12:34:44+00:00", 12, 34, 44, null, TimeSpan.Zero);
accept("12:34:44", 12, 34, 44, null, null);
accept("12:34Z", 12, 34, null, null, TimeSpan.Zero);
accept("12:34", 12, 34, null, null, null);
accept("12", 12, null, null, null, null);
accept("12Z", 12, null, null, null, TimeSpan.Zero);
accept("12-04:30", 12, null, null, null, new TimeSpan(-4, -30, 0));
reject("");
reject("+05:00");
reject("Z");
reject("12:34.1234");
reject("Hi12:34:44");
reject("12:34:44there");
reject("12:34:44+A");
reject("12:34:44+345:432");
reject("92:34:44");
reject("12:34:AM");
void accept(string testValue, int?h, int?m, int?s, int?ms, TimeSpan?o)
{
Assert.IsTrue(PartialTime.TryParse(testValue, out PartialTime parsed), "TryParse");
Assert.AreEqual(h, parsed.Hours, "hours");
Assert.AreEqual(m, parsed.Minutes, "minutes");
Assert.AreEqual(s, parsed.Seconds, "seconds");
Assert.AreEqual(ms, parsed.Millis, "millis");
Assert.AreEqual(o, parsed.Offset, "offset");
Assert.AreEqual(testValue, parsed.ToString(), "ToString");
}
void reject(string testValue)
{
Assert.IsFalse(PartialTime.TryParse(testValue, out _));
}
}
public void FhirPath_Lex_Time()
{
var parser = Lexer.Time.End();
accept("@T12:34:34.345674");
accept("@T12:34:34");
accept("@T12:35");
accept("@T12");
reject("@T12:34:34+02:30");
reject("@T12:34:00Z");
reject("2001-01-01T12:34:34+02:30");
reject("@2001-01-01T12:34:34+02:30");
reject("T12:34:34+02:30");
reject("12:34:34+02:30");
reject("@12:34:34+02:30");
reject("@T12:34:34+48:30");
void accept(string s) => AssertParser.SucceedsMatch(parser, s, PartialTime.Parse(s.Substring(2)));
void reject(string s) => AssertParser.FailsMatch(parser, s);
}
private static object convertXmlStringToPrimitive(Type to, string value)
{
if (typeof(Boolean) == to)
{
return(XmlConvert.ToBoolean(value));
}
if (typeof(Byte) == to)
{
return(XmlConvert.ToByte(value)); // Not used in FHIR serialization
}
if (typeof(Char) == to)
{
return(XmlConvert.ToChar(value)); // Not used in FHIR serialization
}
if (typeof(DateTime) == to)
{
return(ConvertToDatetimeOffset(value).UtcDateTime); // Obsolete: use DateTimeOffset instead!!
}
if (typeof(Decimal) == to)
{
return(XmlConvert.ToDecimal(value));
}
if (typeof(Double) == to)
{
return(XmlConvert.ToDouble(value)); // Could lead to loss in precision
}
if (typeof(Int16) == to)
{
return(XmlConvert.ToInt16(value)); // Could lead to loss in precision
}
if (typeof(Int32) == to)
{
return(XmlConvert.ToInt32(value));
}
if (typeof(Int64) == to)
{
return(XmlConvert.ToInt64(value)); // Not used in FHIR serialization
}
if (typeof(SByte) == to)
{
return(XmlConvert.ToSByte(value)); // Not used in FHIR serialization
}
if (typeof(Single) == to)
{
return(XmlConvert.ToSingle(value)); // Not used in FHIR serialization
}
if (typeof(UInt16) == to)
{
return(XmlConvert.ToUInt16(value)); // Not used in FHIR serialization
}
if (typeof(UInt32) == to)
{
return(XmlConvert.ToUInt32(value)); // Not used in FHIR serialization
}
if (typeof(UInt64) == to)
{
return(XmlConvert.ToUInt64(value)); // Not used in FHIR serialization
}
if (typeof(byte[]) == to)
{
return(System.Convert.FromBase64String(value));
}
if (typeof(DateTimeOffset) == to)
{
return(ConvertToDatetimeOffset(value));
}
if (typeof(System.Uri) == to)
{
return(new Uri(value, UriKind.RelativeOrAbsolute));
}
if (typeof(PartialDateTime) == to)
{
return(PartialDateTime.Parse(value));
}
if (typeof(PartialTime) == to)
{
return(PartialTime.Parse(value));
}
if (typeof(BigInteger) == to)
{
return(BigInteger.Parse(value));
}
if (to.IsEnum())
{
var result = EnumUtility.ParseLiteral(value, to);
if (result == null)
{
throw Error.NotSupported($"String value '{value}' is not a known literal in enum '{to.Name}'");
}
return(result);
}
throw Error.NotSupported($"Cannot convert string value '{value}' to a {to.Name}");
}
public static SymbolTable AddStandardFP(this SymbolTable t)
{
// Functions that operate on the focus, without null propagation
t.Add("empty", (IEnumerable <object> f) => !f.Any());
t.Add("exists", (IEnumerable <object> f) => f.Any());
t.Add("count", (IEnumerable <object> f) => f.Count());
t.Add("trace", (IEnumerable <ITypedElement> f, string name, EvaluationContext ctx)
=> f.Trace(name, ctx));
t.Add("allTrue", (IEnumerable <ITypedElement> f) => f.All(e => e.Value as bool? == true));
t.Add("combine", (IEnumerable <ITypedElement> l, IEnumerable <ITypedElement> r) => l.Concat(r));
t.Add("binary.|", (object f, IEnumerable <ITypedElement> l, IEnumerable <ITypedElement> r) => l.DistinctUnion(r));
t.Add("union", (IEnumerable <ITypedElement> l, IEnumerable <ITypedElement> r) => l.DistinctUnion(r));
t.Add("binary.contains", (object f, IEnumerable <ITypedElement> a, ITypedElement b) => a.Contains(b));
t.Add("binary.in", (object f, ITypedElement a, IEnumerable <ITypedElement> b) => b.Contains(a));
t.Add("distinct", (IEnumerable <ITypedElement> f) => f.Distinct());
t.Add("isDistinct", (IEnumerable <ITypedElement> f) => f.IsDistinct());
t.Add("subsetOf", (IEnumerable <ITypedElement> f, IEnumerable <ITypedElement> a) => f.SubsetOf(a));
t.Add("supersetOf", (IEnumerable <ITypedElement> f, IEnumerable <ITypedElement> a) => a.SubsetOf(f));
t.Add("intersect", (IEnumerable <ITypedElement> f, IEnumerable <ITypedElement> a) => f.Intersect(a));
t.Add("exclude", (IEnumerable <ITypedElement> f, IEnumerable <ITypedElement> a) => f.Exclude(a));
t.Add("today", (object f) => PartialDate.Today());
t.Add("now", (object f) => PartialDateTime.Now());
t.Add("timeOfDay", (object f) => PartialTime.Now());
t.Add("binary.&", (object f, string a, string b) => (a ?? "") + (b ?? ""));
t.Add("iif", (IEnumerable <ITypedElement> f, bool?condition, IEnumerable <ITypedElement> result) => f.IIf(condition, result));
t.Add("iif", (IEnumerable <ITypedElement> f, bool?condition, IEnumerable <ITypedElement> result, IEnumerable <ITypedElement> otherwise) => f.IIf(condition, result, otherwise));
// Functions that use normal null propagation and work with the focus (buy may ignore it)
t.Add("not", (IEnumerable <ITypedElement> f) => f.Not(), doNullProp: true);
t.Add("builtin.children", (IEnumerable <ITypedElement> f, string a) => f.Navigate(a), doNullProp: true);
t.Add("children", (IEnumerable <ITypedElement> f) => f.Children(), doNullProp: true);
t.Add("descendants", (IEnumerable <ITypedElement> f) => f.Descendants(), doNullProp: true);
t.Add("binary.=", (object f, IEnumerable <ITypedElement> a, IEnumerable <ITypedElement> b) => a.IsEqualTo(b), doNullProp: true);
t.Add("binary.!=", (object f, IEnumerable <ITypedElement> a, IEnumerable <ITypedElement> b) => !a.IsEqualTo(b), doNullProp: true);
t.Add("binary.~", (object f, IEnumerable <ITypedElement> a, IEnumerable <ITypedElement> b) => a.IsEquivalentTo(b), doNullProp: true);
t.Add("binary.!~", (object f, IEnumerable <ITypedElement> a, IEnumerable <ITypedElement> b) => !a.IsEquivalentTo(b), doNullProp: true);
t.Add("unary.-", (object f, long a) => - a, doNullProp: true);
t.Add("unary.-", (object f, decimal a) => - a, doNullProp: true);
t.Add("unary.+", (object f, long a) => a, doNullProp: true);
t.Add("unary.+", (object f, decimal a) => a, doNullProp: true);
t.Add("binary.*", (object f, long a, long b) => a * b, doNullProp: true);
t.Add("binary.*", (object f, decimal a, decimal b) => a * b, doNullProp: true);
t.Add("binary.*", (object f, Quantity a, Quantity b) => a * b, doNullProp: true);
t.Add("binary./", (object f, decimal a, decimal b) => a / b, doNullProp: true);
t.Add("binary./", (object f, Quantity a, Quantity b) => a / b, doNullProp: true);
t.Add("binary.+", (object f, long a, long b) => a + b, doNullProp: true);
t.Add("binary.+", (object f, decimal a, decimal b) => a + b, doNullProp: true);
t.Add("binary.+", (object f, string a, string b) => a + b, doNullProp: true);
t.Add("binary.+", (object f, Quantity a, Quantity b) => a + b, doNullProp: true);
t.Add("binary.-", (object f, long a, long b) => a - b, doNullProp: true);
t.Add("binary.-", (object f, decimal a, decimal b) => a - b, doNullProp: true);
t.Add("binary.-", (object f, Quantity a, Quantity b) => a - b, doNullProp: true);
t.Add("binary.div", (object f, long a, long b) => a / b, doNullProp: true);
t.Add("binary.div", (object f, decimal a, decimal b) => (long)Math.Truncate(a / b), doNullProp: true);
t.Add("binary.mod", (object f, long a, long b) => a % b, doNullProp: true);
t.Add("binary.mod", (object f, decimal a, decimal b) => a % b, doNullProp: true);
t.Add("binary.>", (object f, long a, long b) => a > b, doNullProp: true);
t.Add("binary.>", (object f, decimal a, decimal b) => a > b, doNullProp: true);
t.Add("binary.>", (object f, string a, string b) => string.CompareOrdinal(a, b) > 0, doNullProp: true);
t.Add("binary.>", (object f, PartialDateTime a, PartialDateTime b) => a > b, doNullProp: true);
t.Add("binary.>", (object f, PartialTime a, PartialTime b) => a > b, doNullProp: true);
t.Add("binary.>", (object f, PartialDate a, PartialDate b) => a > b, doNullProp: true);
t.Add("binary.>", (object f, Quantity a, Quantity b) => a > b, doNullProp: true);
t.Add("binary.<", (object f, long a, long b) => a < b, doNullProp: true);
t.Add("binary.<", (object f, decimal a, decimal b) => a < b, doNullProp: true);
t.Add("binary.<", (object f, string a, string b) => string.CompareOrdinal(a, b) < 0, doNullProp: true);
t.Add("binary.<", (object f, PartialDateTime a, PartialDateTime b) => a < b, doNullProp: true);
t.Add("binary.<", (object f, PartialTime a, PartialTime b) => a < b, doNullProp: true);
t.Add("binary.<", (object f, PartialDate a, PartialDate b) => a < b, doNullProp: true);
t.Add("binary.<", (object f, Quantity a, Quantity b) => a < b, doNullProp: true);
t.Add("binary.<=", (object f, long a, long b) => a <= b, doNullProp: true);
t.Add("binary.<=", (object f, decimal a, decimal b) => a <= b, doNullProp: true);
t.Add("binary.<=", (object f, string a, string b) => string.CompareOrdinal(a, b) <= 0, doNullProp: true);
t.Add("binary.<=", (object f, PartialDateTime a, PartialDateTime b) => a <= b, doNullProp: true);
t.Add("binary.<=", (object f, PartialTime a, PartialTime b) => a <= b, doNullProp: true);
t.Add("binary.<=", (object f, PartialDate a, PartialDate b) => a <= b, doNullProp: true);
t.Add("binary.<=", (object f, Quantity a, Quantity b) => a <= b, doNullProp: true);
t.Add("binary.>=", (object f, long a, long b) => a >= b, doNullProp: true);
t.Add("binary.>=", (object f, decimal a, decimal b) => a >= b, doNullProp: true);
t.Add("binary.>=", (object f, string a, string b) => string.CompareOrdinal(a, b) >= 0, doNullProp: true);
t.Add("binary.>=", (object f, PartialDateTime a, PartialDateTime b) => a >= b, doNullProp: true);
t.Add("binary.>=", (object f, PartialTime a, PartialTime b) => a >= b, doNullProp: true);
t.Add("binary.>=", (object f, PartialDate a, PartialDate b) => a >= b, doNullProp: true);
t.Add("binary.>=", (object f, Quantity a, Quantity b) => a >= b, doNullProp: true);
t.Add("single", (IEnumerable <ITypedElement> f) => f.Single(), doNullProp: true);
t.Add("skip", (IEnumerable <ITypedElement> f, long a) => f.Skip((int)a), doNullProp: true);
t.Add("first", (IEnumerable <ITypedElement> f) => f.First(), doNullProp: true);
t.Add("last", (IEnumerable <ITypedElement> f) => f.Last(), doNullProp: true);
t.Add("tail", (IEnumerable <ITypedElement> f) => f.Tail(), doNullProp: true);
t.Add("take", (IEnumerable <ITypedElement> f, long a) => f.Take((int)a), doNullProp: true);
t.Add("builtin.item", (IEnumerable <ITypedElement> f, long a) => f.Item((int)a), doNullProp: true);
t.Add("toBoolean", (ITypedElement f) => f.ToBoolean(), doNullProp: true);
t.Add("convertsToBoolean", (ITypedElement f) => f.ConvertsToBoolean(), doNullProp: true);
t.Add("toInteger", (ITypedElement f) => f.ToInteger(), doNullProp: true);
t.Add("convertsToInteger", (ITypedElement f) => f.ConvertsToInteger(), doNullProp: true);
t.Add("toDecimal", (ITypedElement f) => f.ToDecimal(), doNullProp: true);
t.Add("convertsToDecimal", (ITypedElement f) => f.ConvertsToDecimal(), doNullProp: true);
t.Add("toDateTime", (ITypedElement f) => f.ToDateTime(), doNullProp: true);
t.Add("convertsToDateTime", (ITypedElement f) => f.ConvertsToDateTime(), doNullProp: true);
t.Add("toTime", (ITypedElement f) => f.ToTime(), doNullProp: true);
t.Add("convertsToTime", (ITypedElement f) => f.ConvertsToTime(), doNullProp: true);
t.Add("toDate", (ITypedElement f) => f.ToDate(), doNullProp: true);
t.Add("convertsToDate", (ITypedElement f) => f.ConvertsToDate(), doNullProp: true);
t.Add("toString", (ITypedElement f) => f.ToStringRepresentation(), doNullProp: true);
t.Add("convertsToString", (ITypedElement f) => f.ConvertsToString(), doNullProp: true);
t.Add("toQuantity", (ITypedElement f) => f.ToQuantity(), doNullProp: true);
t.Add("convertsToQuantity", (ITypedElement f) => f.ConvertsToQuantity(), doNullProp: true);
t.Add("upper", (string f) => f.ToUpper(), doNullProp: true);
t.Add("lower", (string f) => f.ToLower(), doNullProp: true);
t.Add("toChars", (string f) => f.ToChars(), doNullProp: true);
t.Add("substring", (string f, long a) => f.FpSubstring((int)a), doNullProp: true);
t.Add("substring", (string f, long a, long b) => f.FpSubstring((int)a, (int)b), doNullProp: true);
t.Add("startsWith", (string f, string fragment) => f.StartsWith(fragment), doNullProp: true);
t.Add("endsWith", (string f, string fragment) => f.EndsWith(fragment), doNullProp: true);
t.Add("matches", (string f, string regex) => Regex.IsMatch(f, regex), doNullProp: true);
t.Add("indexOf", (string f, string fragment) => f.FpIndexOf(fragment), doNullProp: true);
t.Add("contains", (string f, string fragment) => f.Contains(fragment), doNullProp: true);
t.Add("replaceMatches", (string f, string regex, string subst) => Regex.Replace(f, regex, subst), doNullProp: true);
t.Add("replace", (string f, string regex, string subst) => f.FpReplace(regex, subst), doNullProp: true);
t.Add("length", (string f) => f.Length, doNullProp: true);
// The next two functions existed pre-normative, so we have kept them.
t.Add("is", (ITypedElement f, string name) => f.Is(name), doNullProp: true);
t.Add("as", (IEnumerable <ITypedElement> f, string name) => f.FilterType(name), doNullProp: true);
t.Add("ofType", (IEnumerable <ITypedElement> f, string name) => f.FilterType(name), doNullProp: true);
t.Add("binary.is", (object f, ITypedElement left, string name) => left.Is(name), doNullProp: true);
t.Add("binary.as", (object f, ITypedElement left, string name) => left.CastAs(name), doNullProp: true);
// Kept for backwards compatibility, but no longer part of the spec
t.Add("binary.as", (object f, IEnumerable <ITypedElement> left, string name) => left.FilterType(name), doNullProp: true);
t.Add("extension", (IEnumerable <ITypedElement> f, string url) => f.Extension(url), doNullProp: true);
// Logic operators do not use null propagation and may do short-cut eval
t.AddLogic("binary.and", (a, b) => a.And(b));
t.AddLogic("binary.or", (a, b) => a.Or(b));
t.AddLogic("binary.xor", (a, b) => a.XOr(b));
t.AddLogic("binary.implies", (a, b) => a.Implies(b));
// Special late-bound functions
t.Add(new CallSignature("where", typeof(IEnumerable <ITypedElement>), typeof(object), typeof(Invokee)), runWhere);
t.Add(new CallSignature("select", typeof(IEnumerable <ITypedElement>), typeof(object), typeof(Invokee)), runSelect);
t.Add(new CallSignature("all", typeof(bool), typeof(object), typeof(Invokee)), runAll);
t.Add(new CallSignature("any", typeof(bool), typeof(object), typeof(Invokee)), runAny);
t.Add(new CallSignature("repeat", typeof(IEnumerable <ITypedElement>), typeof(object), typeof(Invokee)), runRepeat);
t.Add(new CallSignature("trace", typeof(IEnumerable <ITypedElement>), typeof(string), typeof(object), typeof(Invokee)), Trace);
t.AddVar("sct", "http://snomed.info/sct");
t.AddVar("loinc", "http://loinc.org");
t.AddVar("ucum", "http://unitsofmeasure.org");
t.Add("builtin.coreexturl", (object f, string id) => getCoreExtensionUrl(id));
t.Add("builtin.corevsurl", (object f, string id) => getCoreValueSetUrl(id));
return(t);
}
private void SucceedsTime(Parser <PartialTime> parser, string s)
{
AssertParser.SucceedsMatch(parser, s, PartialTime.Parse(s.Substring(2)));
}
private static object convertXmlStringToPrimitive(Type to, string value)
{
if (typeof(Boolean) == to)
{
return(XmlConvert.ToBoolean(value));
}
if (typeof(Byte) == to)
{
return(XmlConvert.ToByte(value)); // Not used in FHIR serialization
}
if (typeof(Char) == to)
{
return(XmlConvert.ToChar(value)); // Not used in FHIR serialization
}
if (typeof(DateTime) == to)
{
return(ConvertToDatetimeOffset(value).UtcDateTime); // Obsolete: use DateTimeOffset instead!!
}
if (typeof(Decimal) == to)
{
if (FORBIDDEN_DECIMAL_PREFIXES.Any(prefix => value.StartsWith(prefix)) || value.EndsWith("."))
{
// decimal cannot start with '+', '-' or '00' and cannot end with '.'
throw new FormatException("Input string was not in a correct format.");
}
return(decimal.Parse(value, NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent | NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture));
}
if (typeof(Double) == to)
{
return(XmlConvert.ToDouble(value)); // Could lead to loss in precision
}
if (typeof(Int16) == to)
{
return(XmlConvert.ToInt16(value)); // Could lead to loss in precision
}
if (typeof(Int32) == to)
{
return(XmlConvert.ToInt32(value));
}
if (typeof(Int64) == to)
{
return(XmlConvert.ToInt64(value)); // Not used in FHIR serialization
}
if (typeof(SByte) == to)
{
return(XmlConvert.ToSByte(value)); // Not used in FHIR serialization
}
if (typeof(Single) == to)
{
return(XmlConvert.ToSingle(value)); // Not used in FHIR serialization
}
if (typeof(UInt16) == to)
{
return(XmlConvert.ToUInt16(value)); // Not used in FHIR serialization
}
if (typeof(UInt32) == to)
{
return(XmlConvert.ToUInt32(value)); // Not used in FHIR serialization
}
if (typeof(UInt64) == to)
{
return(XmlConvert.ToUInt64(value)); // Not used in FHIR serialization
}
if (typeof(byte[]) == to)
{
return(System.Convert.FromBase64String(value));
}
if (typeof(DateTimeOffset) == to)
{
return(ConvertToDatetimeOffset(value));
}
if (typeof(System.Uri) == to)
{
return(new Uri(value, UriKind.RelativeOrAbsolute));
}
if (typeof(PartialDateTime) == to)
{
return(PartialDateTime.Parse(value));
}
if (typeof(PartialTime) == to)
{
return(PartialTime.Parse(value));
}
if (typeof(BigInteger) == to)
{
return(BigInteger.Parse(value));
}
if (to.IsEnum())
{
var result = EnumUtility.ParseLiteral(value, to);
if (result == null)
{
throw Error.NotSupported($"String value '{value}' is not a known literal in enum '{to.Name}'");
}
return(result);
}
throw Error.NotSupported($"Cannot convert string value '{value}' to a {to.Name}");
}
