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);
}
