public void Session_FnLotDate_ReturnsDateFromFirstArgAmount() { Session session = new Session(); Amount amount1 = new Amount(0); // No date CallScope scope1 = new CallScope(new EmptyScope()); //scope1.PushBack(Value.Get(false)); // first argument scope1.PushBack(Value.Get(amount1)); Assert.AreEqual(Value.Empty, session.FnLotDate(scope1)); Commodity commodity = new Commodity(CommodityPool.Current, new CommodityBase("base")); Date date = (Date)DateTime.Now.Date; Annotation annotation = new Annotation() { Date = date }; AnnotatedCommodity annotatedCommodity = new AnnotatedCommodity(commodity, annotation); Amount amount2 = new Amount(BigInt.FromInt(10), annotatedCommodity); // With date CallScope scope2 = new CallScope(new EmptyScope()); //scope2.PushBack(Value.Get(false)); // first argument scope2.PushBack(Value.Get(amount2)); Assert.AreEqual(date, session.FnLotDate(scope2).AsDate); }
public void AnnotatedCommodity_StripAnnotations_CanKeepvEverything() { Commodity commodity = new Commodity(CommodityPool.Current, new CommodityBase("comm")); AnnotatedCommodity annCommodity = new AnnotatedCommodity(commodity, new Annotation(new Amount(10), (Date)DateTime.Now.Date, "tag") { IsPriceFixated = true, IsPriceCalculated = true, IsDateCalculated = true, IsTagCalculated = true }); AnnotationKeepDetails keepDetails = new AnnotationKeepDetails() { KeepPrice = true, KeepDate = true, KeepTag = true }; Commodity newCommodity = annCommodity.StripAnnotations(keepDetails); Assert.IsNotNull(newCommodity); Assert.AreEqual(annCommodity, newCommodity); Assert.IsFalse(Object.ReferenceEquals(annCommodity, newCommodity)); Assert.IsTrue(newCommodity.IsAnnotated); AnnotatedCommodity newAnnCommodity = (AnnotatedCommodity)newCommodity; Assert.AreEqual(annCommodity.Details.Price, newAnnCommodity.Details.Price); Assert.AreEqual(annCommodity.Details.Date, newAnnCommodity.Details.Date); Assert.AreEqual(annCommodity.Details.Tag, newAnnCommodity.Details.Tag); // Flags are added even though they were not set in the original commodity Assert.IsTrue(newAnnCommodity.Details.IsPriceCalculated); Assert.IsTrue(newAnnCommodity.Details.IsPriceFixated); Assert.IsTrue(newAnnCommodity.Details.IsDateCalculated); Assert.IsTrue(newAnnCommodity.Details.IsTagCalculated); }
public void Session_FnLotTag_ReturnsDateFromFirstArgAmouunt() { Session session = new Session(); Amount amount1 = new Amount(0); // No tag CallScope scope1 = new CallScope(new EmptyScope()); //scope1.PushBack(Value.Get(false)); // first argument scope1.PushBack(Value.Get(amount1)); Assert.AreEqual(Value.Empty, session.FnLotTag(scope1)); Commodity commodity = new Commodity(CommodityPool.Current, new CommodityBase("base")); string tag = "my-tag"; Annotation annotation = new Annotation() { Tag = tag }; AnnotatedCommodity annotatedCommodity = new AnnotatedCommodity(commodity, annotation); Amount amount2 = new Amount(BigInt.FromInt(10), annotatedCommodity); // With date CallScope scope2 = new CallScope(new EmptyScope()); //scope2.PushBack(Value.Get(false)); // first argument scope2.PushBack(Value.Get(amount2)); Assert.AreEqual(tag, session.FnLotTag(scope2).AsString); }
public void Commodity_CompareByCommodity_ReturnsZeroForEqualAnnotatedCommodities() { Commodity commodity1 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm1 = new AnnotatedCommodity(commodity1, new Annotation()); Commodity commodity2 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm2 = new AnnotatedCommodity(commodity2, new Annotation()); Amount amount1 = new Amount(0, annComm1); Amount amount2 = new Amount(0, annComm2); Assert.Equal(0, Commodity.CompareByCommodity(amount1, amount2)); annComm1.Details.Price = new Amount(5); annComm2.Details.Price = new Amount(5); Assert.Equal(0, Commodity.CompareByCommodity(amount1, amount2)); annComm1.Details.Tag = "tag-1"; annComm2.Details.Tag = "tag-1"; Assert.Equal(0, Commodity.CompareByCommodity(amount1, amount2)); annComm1.Details.Date = (Date)DateTime.UtcNow.Date; annComm2.Details.Date = annComm1.Details.Date; Assert.Equal(0, Commodity.CompareByCommodity(amount1, amount2)); }
public void Amount_HasAnnotation_FailsIfAnnotatedCommodityHasNoDetails() { Commodity comm = new Commodity(CommodityPool.Current, new CommodityBase("comm")); AnnotatedCommodity annComm = new AnnotatedCommodity(comm, null); Amount amount = new Amount(1, annComm); Assert.IsTrue(amount.HasAnnotation); }
public void Amount_HasAnnotation_ReturnsTrueIfCommodityIsAnnotated() { Commodity comm = new Commodity(CommodityPool.Current, new CommodityBase("comm")); AnnotatedCommodity annComm = new AnnotatedCommodity(comm, new Annotation()); Amount amount = new Amount(1, annComm); Assert.IsTrue(amount.HasAnnotation); }
public void Amount_HasAnnotation_FailsIfAnnotatedCommodityHasNoDetails() { Commodity comm = new Commodity(CommodityPool.Current, new CommodityBase("comm")); AnnotatedCommodity annComm = new AnnotatedCommodity(comm, null); Amount amount = new Amount(1, annComm); Assert.Throws <InvalidOperationException>(() => amount.HasAnnotation); }
public void Amount_HasAnnotation_FailsIfAnnotatedCommodityHasNoDetails() { Commodity comm = new Commodity(CommodityPool.Current, new CommodityBase("comm")); AnnotatedCommodity annComm = new AnnotatedCommodity(comm, null); /* not sure it is a valid case. TBD */ Amount amount = new Amount(BigInt.FromInt(1), annComm); Assert.IsTrue(amount.HasAnnotation); }
public void AnnotatedCommodity_Equals_ChecksIsAnnotated() { Date date = (Date)DateTime.Now.Date; Commodity commodity = new Commodity(CommodityPool.Current, new CommodityBase("comm")); AnnotatedCommodity annCommodity1 = new AnnotatedCommodity(commodity, new Annotation(new Amount(10), date, "tag")); AnnotatedCommodity annCommodity2 = new AnnotatedCommodity(commodity, new Annotation(new Amount(10), date, "tag")); Assert.IsFalse(annCommodity1.Equals(commodity)); Assert.IsTrue(annCommodity1.Equals(annCommodity2)); }
public void AnnotatedCommodity_Constructor_PopulatesQualifiedSymbol() { Date date = (Date)DateTime.Now.Date; Commodity commodity = new Commodity(CommodityPool.Current, new CommodityBase("ann-comm-q-test")); commodity.QualifiedSymbol = "qualified-symbol"; AnnotatedCommodity annCommodity1 = new AnnotatedCommodity(commodity, new Annotation(new Amount(10), date, "tag")); Assert.AreEqual("qualified-symbol", annCommodity1.QualifiedSymbol); }
public void AnnotatedCommodity_Equals_ComparesDetails() { Date date = (Date)DateTime.Now.Date; Commodity commodity = new Commodity(CommodityPool.Current, new CommodityBase("comm")); AnnotatedCommodity annCommodity1 = new AnnotatedCommodity(commodity, new Annotation(new Amount(10), date, "tag")); AnnotatedCommodity annCommodity2 = new AnnotatedCommodity(commodity, new Annotation(new Amount(10), date, "tag")); AnnotatedCommodity annCommodity3 = new AnnotatedCommodity(commodity, new Annotation(new Amount(20), date, "tagq")); Assert.True(annCommodity1.Equals(annCommodity2)); Assert.False(annCommodity1.Equals(annCommodity3)); Assert.False(annCommodity2.Equals(annCommodity3)); }
public void Amount_StripAnnotations_ReturnsNewAmountForAnnotatedCommodity() { Commodity comm = new Commodity(CommodityPool.Current, new CommodityBase("comm")); AnnotatedCommodity annComm = new AnnotatedCommodity(comm, new Annotation()); Amount amount = new Amount(10, annComm); AnnotationKeepDetails keepDetails = new AnnotationKeepDetails(); // The original ampunt has annotated commodity, but "keepDetails" does not specify anything to keep. // Therefore, the new amount has not annotated commodity Amount newAmount = amount.StripAnnotations(keepDetails); Assert.IsFalse(newAmount.Commodity.IsAnnotated); }
public void CommodityPool_FindBySymbolAndDetails_ReturnsAnnotatedCommodityIfExists() { TestCommodityPool commodityPool = new TestCommodityPool(); string symbol = "symbol"; string wrongSymbol = "dummy"; Annotation details = new Annotation(); Commodity commodity = commodityPool.Create(symbol); AnnotatedCommodity annotatedCommodity = commodityPool.Create(commodity, details) as AnnotatedCommodity; Assert.Equal(annotatedCommodity, commodityPool.Find(symbol, details)); Assert.Null(commodityPool.Find(wrongSymbol)); }
public void Commodity_CompareByCommodity_ChecksWhetherCommoditiesAreAnnotated() { Commodity commodity1 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm1 = new AnnotatedCommodity(commodity1, new Annotation()); Commodity commodity2 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); Amount amount1 = new Amount(0, commodity1); Amount amount2 = new Amount(0, annComm1); Amount amount3 = new Amount(0, commodity2); Assert.IsTrue(Commodity.CompareByCommodity(amount1, amount2)); Assert.IsFalse(Commodity.CompareByCommodity(amount1, amount3)); Assert.IsFalse(Commodity.CompareByCommodity(amount2, amount1)); }
public void Commodity_Equals_IgnoresAnnotatedCommodities() { CommodityBase commBase1 = new CommodityBase("comm1"); Commodity commodity11 = new Commodity(CommodityPool.Current, commBase1); Commodity commodity12 = new Commodity(CommodityPool.Current, commBase1); AnnotatedCommodity annCommodity = new AnnotatedCommodity(commodity11, new Annotation(new Amount(10), (Date)DateTime.Now.Date, "tag")); Assert.IsTrue(commodity11.Equals(commodity11)); Assert.IsTrue(commodity11.Equals(commodity12)); Assert.IsFalse(commodity11.Equals(annCommodity)); Assert.IsTrue(commodity11 == commodity11); Assert.IsTrue(commodity11 == commodity12); Assert.IsTrue(commodity11 != annCommodity); }
public void CommodityPool_FindOrCreateByCommodityAndDetails_CreatesAnnotatedCommodity() { TestCommodityPool commodityPool = new TestCommodityPool(); string symbol = "symbol"; Annotation details = new Annotation(); Commodity commodity = commodityPool.Create(symbol); AnnotatedCommodity annotatedCommodity = commodityPool.FindOrCreate(commodity, details) as AnnotatedCommodity; Assert.NotNull(annotatedCommodity); Assert.Equal(details, annotatedCommodity.Details); AnnotatedCommodity annotatedCommodity2 = commodityPool.FindOrCreate(commodity, details) as AnnotatedCommodity; Assert.Equal(annotatedCommodity, annotatedCommodity2); }
public void Amount_Annotate_CreatesNewAnnotatedCommodityForAnnotated() { Commodity commodity1 = new Commodity(CommodityPool.Current, new CommodityBase("aac-base-1")); AnnotatedCommodity annotatedCommodity1 = new AnnotatedCommodity(commodity1, new Annotation()); Amount amount1 = new Amount(10, annotatedCommodity1); Annotation newAnnotation = new Annotation(); Assert.IsTrue(amount1.Commodity.IsAnnotated); amount1.Annotate(newAnnotation); Assert.IsTrue(amount1.HasAnnotation); Assert.IsTrue(amount1.Commodity.IsAnnotated); AnnotatedCommodity resultCommodity = (AnnotatedCommodity)amount1.Commodity; Assert.AreEqual(newAnnotation, resultCommodity.Details); }
public void Commodity_Equals_IgnoresAnnotatedCommodities() { CommodityBase commBase1 = new CommodityBase("comm1"); Commodity commodity11 = new Commodity(CommodityPool.Current, commBase1); Commodity commodity12 = new Commodity(CommodityPool.Current, commBase1); AnnotatedCommodity annCommodity = new AnnotatedCommodity(commodity11, new Annotation(new Amount(10), (Date)DateTime.Now.Date, "tag")); Assert.IsTrue(commodity11.Equals(commodity11)); Assert.IsTrue(commodity11.Equals(commodity12)); Assert.IsFalse(commodity11.Equals(annCommodity)); // [DM] Hide warning "Comparison made to the same variable" #pragma warning disable 1718 Assert.IsTrue(commodity11 == commodity11); #pragma warning restore Assert.IsTrue(commodity11 == commodity12); Assert.IsTrue(commodity11 != annCommodity); }
public void Commodity_CompareByCommodity_ComparesTags() { Commodity commodity1 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm1 = new AnnotatedCommodity(commodity1, new Annotation()); Commodity commodity2 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm2 = new AnnotatedCommodity(commodity2, new Annotation()); Amount amount1 = new Amount(0, annComm1); Amount amount2 = new Amount(0, annComm2); annComm1.Details.Tag = "tag-1"; Assert.IsFalse(Commodity.CompareByCommodity(amount1, amount2)); Assert.IsTrue(Commodity.CompareByCommodity(amount2, amount1)); annComm1.Details.Tag = "tag-1"; annComm2.Details.Tag = "tag-2"; Assert.IsTrue(Commodity.CompareByCommodity(amount1, amount2)); Assert.IsFalse(Commodity.CompareByCommodity(amount2, amount1)); }
public void Commodity_CompareByCommodity_ComparesDates() { Commodity commodity1 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm1 = new AnnotatedCommodity(commodity1, new Annotation()); Commodity commodity2 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm2 = new AnnotatedCommodity(commodity2, new Annotation()); Amount amount1 = new Amount(0, annComm1); Amount amount2 = new Amount(0, annComm2); annComm1.Details.Date = (Date)DateTime.UtcNow.Date; Assert.IsFalse(Commodity.CompareByCommodity(amount1, amount2)); Assert.IsTrue(Commodity.CompareByCommodity(amount2, amount1)); annComm1.Details.Date = (Date)DateTime.UtcNow.Date; annComm2.Details.Date = (Date)DateTime.UtcNow.Date.AddDays(1); Assert.IsTrue(Commodity.CompareByCommodity(amount1, amount2)); Assert.IsFalse(Commodity.CompareByCommodity(amount2, amount1)); }
public void AnnotationKeepDetails_KeepAll_IfCommodityIsNotAnnotated() { AnnotationKeepDetails detailsKeepAllTrue = new AnnotationKeepDetails() { KeepPrice = true, KeepDate = true, KeepTag = true, OnlyActuals = false }; AnnotationKeepDetails detailsKeepAllFalse = new AnnotationKeepDetails() { KeepPrice = true, KeepDate = true, KeepTag = true, OnlyActuals = true }; Commodity commodity = new Commodity(CommodityPool.Current, new CommodityBase("comm")); AnnotatedCommodity annCommodity = new AnnotatedCommodity(commodity, new Annotation()); Assert.True(detailsKeepAllTrue.KeepAll(commodity)); Assert.True(detailsKeepAllTrue.KeepAll(annCommodity)); Assert.True(detailsKeepAllFalse.KeepAll(commodity)); Assert.False(detailsKeepAllFalse.KeepAll(annCommodity)); }
public void AnnotationKeepDetails_KeepAny_IfCommodityIsAnnotated() { AnnotationKeepDetails detailsKeepAnyTrue = new AnnotationKeepDetails() { KeepPrice = true, KeepDate = true, KeepTag = true }; AnnotationKeepDetails detailsKeepAnyFalse = new AnnotationKeepDetails() { KeepPrice = false, KeepDate = false, KeepTag = false }; Commodity commodity = new Commodity(CommodityPool.Current, new CommodityBase("comm")); AnnotatedCommodity annCommodity = new AnnotatedCommodity(commodity, new Annotation()); Assert.False(detailsKeepAnyTrue.KeepAny(commodity)); Assert.True(detailsKeepAnyTrue.KeepAny(annCommodity)); Assert.False(detailsKeepAnyFalse.KeepAny(commodity)); Assert.False(detailsKeepAnyFalse.KeepAny(annCommodity)); }
public void Commodity_CompareByCommodity_ComparesPrices() { Commodity commodity1 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm1 = new AnnotatedCommodity(commodity1, new Annotation()); Commodity commodity2 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm2 = new AnnotatedCommodity(commodity2, new Annotation()); Amount amount1 = new Amount(0, annComm1); Amount amount2 = new Amount(0, annComm2); annComm1.Details.Price = new Amount(10); Assert.Equal(1, Commodity.CompareByCommodity(amount1, amount2)); Assert.Equal(-1, Commodity.CompareByCommodity(amount2, amount1)); annComm1.Details.Price = new Amount(5); annComm2.Details.Price = new Amount(10); Assert.Equal(-1, Commodity.CompareByCommodity(amount1, amount2)); Assert.Equal(1, Commodity.CompareByCommodity(amount2, amount1)); }
public void Commodity_CompareByCommodity_ComparesPrices() { Commodity commodity1 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm1 = new AnnotatedCommodity(commodity1, new Annotation()); Commodity commodity2 = new Commodity(CommodityPool.Current, new CommodityBase("comm1")); AnnotatedCommodity annComm2 = new AnnotatedCommodity(commodity2, new Annotation()); Amount amount1 = new Amount(BigInt.FromLong(0), annComm1); Amount amount2 = new Amount(BigInt.FromLong(0), annComm2); annComm1.Details.Price = new Amount(10); Assert.IsFalse(Commodity.CompareByCommodity(amount1, amount2)); Assert.IsTrue(Commodity.CompareByCommodity(amount2, amount1)); annComm1.Details.Price = new Amount(5); annComm2.Details.Price = new Amount(10); Assert.IsTrue(Commodity.CompareByCommodity(amount1, amount2)); Assert.IsFalse(Commodity.CompareByCommodity(amount2, amount1)); }
public void CommodityPool_CreateByCommodityAndDetails_CreatesCommodityAndAddsToPool() { TestCommodityPool commodityPool = new TestCommodityPool(); string symbol = "symbol"; Commodity commodity = commodityPool.Create(symbol); Annotation details = new Annotation(); AnnotatedCommodity annotatedCommodity = commodityPool.Create(commodity, details) as AnnotatedCommodity; Assert.NotNull(annotatedCommodity); Assert.Equal(details, annotatedCommodity.Details); Assert.Equal(symbol, annotatedCommodity.BaseSymbol); Assert.Equal(symbol, annotatedCommodity.Symbol); Assert.Null(annotatedCommodity.QualifiedSymbol); Assert.True(commodityPool.Commodities.ContainsKey(symbol)); Assert.Equal(commodity, commodityPool.Commodities[symbol]); Assert.True(commodityPool.AnnotatedCommodities.ContainsKey(new Tuple <string, Annotation>(symbol, details))); Assert.Equal(annotatedCommodity, commodityPool.AnnotatedCommodities[new Tuple <string, Annotation>(symbol, details)]); }
public void Session_FnLotPrice_ReturnsPriceFromFirstArgAmouunt() { Session session = new Session(); Amount amount1 = new Amount(0); // No price CallScope scope1 = new CallScope(new EmptyScope()); //scope1.PushBack(Value.Get(false)); // first argument scope1.PushBack(Value.Get(amount1)); Assert.AreEqual(Value.Empty, session.FnLotPrice(scope1)); Commodity commodity = new Commodity(CommodityPool.Current, new CommodityBase("base")); Amount price = new Amount(5); Annotation annotation = new Annotation(price); AnnotatedCommodity annotatedCommodity = new AnnotatedCommodity(commodity, annotation); Amount amount2 = new Amount(BigInt.FromInt(10), annotatedCommodity); // With price CallScope scope2 = new CallScope(new EmptyScope()); //scope2.PushBack(Value.Get(false)); // first argument scope2.PushBack(Value.Get(amount2)); Assert.AreEqual(price, session.FnLotPrice(scope2).AsAmount); }
public Commodity Create(Commodity commodity, Annotation details) { if (commodity == null) { throw new ArgumentNullException("commodity"); } if (commodity.IsAnnotated) { throw new ArgumentException("Commodity is already annotated"); } if (details == null) { throw new ArgumentNullException("details"); } Logger.Debug("pool.commodities", () => String.Format("commodity_pool_t::create[ann:comm] symbol {0}\r\n{1}", commodity.BaseSymbol, details)); AnnotatedCommodity annotatedCommodity = new AnnotatedCommodity(commodity, details); commodity.Flags |= CommodityFlagsEnum.COMMODITY_SAW_ANNOTATED; if (details.Price != null) { if (details.IsPriceFixated) { commodity.Flags |= CommodityFlagsEnum.COMMODITY_SAW_ANN_PRICE_FIXATED; } else { commodity.Flags |= CommodityFlagsEnum.COMMODITY_SAW_ANN_PRICE_FLOAT; } } Logger.Debug("pool.commodities", () => String.Format("Creating annotated commodity symbol {0}\r\n{1}", commodity.BaseSymbol, details)); AnnotatedCommodities.Add(new Tuple <string, Annotation>(commodity.BaseSymbol, details), annotatedCommodity); return(annotatedCommodity); }
public override void Handle(Post post) { Amount temp = post.Amount.StripAnnotations(Report.WhatToKeep()); Commodity comm = temp.Commodity; int count; if (!Commodities.TryGetValue(comm, out count)) { count = 0; } Commodities[comm] = count + 1; if (comm.IsAnnotated) { AnnotatedCommodity annComm = (AnnotatedCommodity)comm; if (annComm.Details.Price != null) { if (!Commodities.TryGetValue(annComm.Details.Price.Commodity, out count)) { count = 0; } Commodities[annComm.Details.Price.Commodity] = count + 1; } } if (post.Cost != null) { Amount tempCost = post.Cost.StripAnnotations(Report.WhatToKeep()); if (!Commodities.TryGetValue(tempCost.Commodity, out count)) { count = 0; } Commodities[tempCost.Commodity] = count + 1; } }
public void CommodityPool_FindWithAnnotation_IgnoresAnnotationFlags() { TestCommodityPool commodityPool = new TestCommodityPool(); string symbol = "symbol"; Annotation details = new Annotation(); Commodity commodity = commodityPool.Create(symbol); AnnotatedCommodity annotatedCommodity = commodityPool.FindOrCreate(commodity, details) as AnnotatedCommodity; // The same annotation but with another flags - annotated commodity is found Annotation details1 = new Annotation() { IsPriceFixated = true }; Assert.NotNull(commodityPool.Find(symbol, details1)); // Another annotation - no results Annotation details2 = new Annotation() { Tag = "tag" }; Assert.Null(commodityPool.Find(symbol, details2)); }
/// <summary> /// Ported from bool commodity_t::compare_by_commodity::operator() /// </summary> public static int CompareByCommodity(Amount left, Amount right) { if (left == null) { throw new ArgumentNullException("left"); } if (right == null) { throw new ArgumentNullException("right"); } Commodity leftComm = left.Commodity; Commodity rightComm = right.Commodity; Logger.Current.Debug(DebugCommodityCompare, () => String.Format(" left symbol ({0})", leftComm)); Logger.Current.Debug(DebugCommodityCompare, () => String.Format("right symbol ({0})", rightComm)); if (leftComm.BaseSymbol != rightComm.BaseSymbol) { Logger.Current.Debug(DebugCommodityCompare, () => "symbol is <"); return(String.Compare(leftComm.BaseSymbol, rightComm.BaseSymbol, StringComparison.Ordinal)); } if (!leftComm.IsAnnotated && rightComm.IsAnnotated) { Logger.Current.Debug(DebugCommodityCompare, () => "left has no annotation, right does"); return(-1); } else if (leftComm.IsAnnotated && !rightComm.IsAnnotated) { Logger.Current.Debug(DebugCommodityCompare, () => "right has no annotation, left does"); return(1); } else if (!leftComm.IsAnnotated && !rightComm.IsAnnotated) { Logger.Current.Debug(DebugCommodityCompare, () => "there are no annotations, commodities match"); return(0); } AnnotatedCommodity aLeftComm = (AnnotatedCommodity)leftComm; AnnotatedCommodity aRightComm = (AnnotatedCommodity)rightComm; if (aLeftComm.Details.Price == null && aRightComm.Details.Price != null) { Logger.Current.Debug(DebugCommodityCompare, () => "left has no price, right does"); return(-1); } if (aLeftComm.Details.Price != null && aRightComm.Details.Price == null) { Logger.Current.Debug(DebugCommodityCompare, () => "right has no price, left does"); return(1); } if (aLeftComm.Details.Price != null && aRightComm.Details.Price != null) { Amount leftPrice = aLeftComm.Details.Price; Amount rightPrice = aRightComm.Details.Price; if (leftPrice.Commodity != rightPrice.Commodity) { // Since we have two different amounts, there's really no way // to establish a true sorting order; we'll just do it based // on the numerical values. leftPrice = new Amount(leftPrice.Quantity, null); rightPrice = new Amount(rightPrice.Quantity, null); Logger.Current.Debug(DebugCommodityCompare, () => "both have price, commodities don't match, recursing"); int cmp2 = CompareByCommodity(leftPrice, rightPrice); if (cmp2 != 0) { Logger.Current.Debug(DebugCommodityCompare, () => "recursion found a disparity"); return(cmp2); } } else { if (leftPrice.IsLessThan(rightPrice)) { Logger.Current.Debug(DebugCommodityCompare, () => "left price is less"); return(-1); } else if (leftPrice.IsGreaterThan(rightPrice)) { Logger.Current.Debug(DebugCommodityCompare, () => "left price is more"); return(1); } } } if (aLeftComm.Details.Date == null && aRightComm.Details.Date != null) { Logger.Current.Debug(DebugCommodityCompare, () => "left has no date, right does"); return(-1); } if (aLeftComm.Details.Date != null && aRightComm.Details.Date == null) { Logger.Current.Debug(DebugCommodityCompare, () => "right has no date, left does"); return(1); } if (aLeftComm.Details.Date != null && aRightComm.Details.Date != null) { Logger.Current.Debug(DebugCommodityCompare, () => "both have dates, comparing on difference"); TimeSpan diff = aLeftComm.Details.Date.Value - aRightComm.Details.Date.Value; if (diff.Ticks < 0) { Logger.Current.Debug(DebugCommodityCompare, () => "dates differ"); return(-1); } if (diff.Ticks > 0) { Logger.Current.Debug(DebugCommodityCompare, () => "dates differ"); return(1); } } if (String.IsNullOrEmpty(aLeftComm.Details.Tag) && !String.IsNullOrEmpty(aRightComm.Details.Tag)) { Logger.Current.Debug(DebugCommodityCompare, () => "left has no tag, right does"); return(-1); } if (!String.IsNullOrEmpty(aLeftComm.Details.Tag) && String.IsNullOrEmpty(aRightComm.Details.Tag)) { Logger.Current.Debug(DebugCommodityCompare, () => "right has no tag, left does"); return(1); } if (!String.IsNullOrEmpty(aLeftComm.Details.Tag) && !String.IsNullOrEmpty(aRightComm.Details.Tag)) { Logger.Current.Debug(DebugCommodityCompare, () => "both have tags, comparing lexically"); return(aLeftComm.Details.Tag.CompareTo(aRightComm.Details.Tag)); } if (aLeftComm.Details.ValueExpr == null && aLeftComm.Details.ValueExpr != null) { Logger.Current.Debug(DebugCommodityCompare, () => "left has no value expr, right does"); return(-1); } if (aLeftComm.Details.ValueExpr != null && aLeftComm.Details.ValueExpr == null) { Logger.Current.Debug(DebugCommodityCompare, () => "right has no value expr, left does"); return(1); } if (aLeftComm.Details.ValueExpr != null && aLeftComm.Details.ValueExpr != null) { Logger.Current.Debug(DebugCommodityCompare, () => "both have value exprs, comparing text reprs"); return(aLeftComm.Details.ValueExpr.Text.CompareTo(aLeftComm.Details.ValueExpr.Text)); } Logger.Current.Debug(DebugCommodityCompare, () => "the two are incomparable, which should never happen"); // assert(false); // return -1; // [DM] It is an important difference between ledger and nledger code: we need to return "0" here for equal annotated commodities. // Otherwise, stable sort in OrderBy will not work. return(0); }