public void RemoveItem(BondStructureDefinition def_, bool deleteFromUnderlyingCache_ = false)
{
if (Items.Contains(def_))
{
if (deleteFromUnderlyingCache_)
{
Singleton<BondStructureDefinitionCache>.Instance.RemoveDefinition(def_);
}
else
{
Items.Remove(def_);
OnFolderContentsChanged(new BondStructureFolderChangedArgs(
folder_: this,
addedOrRemovedDefinition_: def_,
action_: CacheAction.StructureRemoved));
// if the folder has become empty, then delete it
if (MarkedForRemoval && Items.Count == 0 && SubFolders.Count == 0 && Parent != null)
{
Parent.OnFolderContentsChanged(new BondStructureFolderChangedArgs(Parent, this, CacheAction.FolderRemoved));
}
}
}
}
public StructureNode(BondStructureDefinition def_)
{
Text = def_.Name;
LeftImages.Add(BSAResources.share_icon_16black);
m_def = def_;
}
public BondStructure(BondStructureDefinition def_)
: base(def_.Name)
{
foreach (var comp in def_.Items)
{
var item = new BondStructureComponent()
{
Bond = BondAnalysisLineHelper.FindBondFromDefinition(comp),
Multiplier = comp.Multiplier
};
Add(item);
}
setPriorValue();
SetNameSortingDate();
recalculateLive(true);
}
public async void SaveDefinitionToCache(string name_, string[] folderPath_=null)
{
if (!IsDefinitionComplete())
{
Logger.Error(string.Format("Attempt to save {0} structure that isn't complete. I'm not doing it", name_),
typeof (BondStructure));
return;
}
var def = new BondStructureDefinition()
{
Name = name_,
Owner = SymmetryEnvironment.UserName,
FolderTree=folderPath_
};
foreach (var comp in Components)
def.Items.Add(new BondStructureDefinitionItem()
{
Multiplier = comp.Multiplier,
Market = comp.Bond.ParentSource.Market,
Month = comp.Bond.UnderlyingBond.Maturity.Month,
Year = comp.Bond.UnderlyingBond.Maturity.Year,
Coupon = comp.Bond.UnderlyingBond.Coupon
});
await Singleton<BondStructureDefinitionCache>.Instance.AddOrUpdateDefinition(def);
}
public override void Dispose()
{
m_def = null;
base.Dispose();
}
public StructureClickedArgs(BondStructureDefinition def_, MouseButtons buttons_)
{
Structure = def_;
Buttons = buttons_;
}
/// <summary>
/// Place Item within this
/// </summary>
/// <param name="def_"></param>
public async void PlaceItemWithinYou(BondStructureDefinition def_, bool addToUnderlyingCache_=true)
{
var currentFolder = BondStructureFolder.RootFolder.getSubFolder(
folders_: def_.FolderTree,
createIfNotThere_: false);
var path = fullPathToThisFolder;
bool pathAlreadySetCorrectly = false;
if (def_.FolderTree!=null && path.Length == def_.FolderTree.Length)
{
pathAlreadySetCorrectly = !path.Where((t, i) => !t.Equals(def_.FolderTree[i])).Any();
}
if (currentFolder != null && !pathAlreadySetCorrectly)
currentFolder.RemoveItem(def_, false);
// set the path
def_.FolderTree = (path == null || path.Length == 0) ? null : path;
// update the cache (will delete the old version)
if (addToUnderlyingCache_)
{
await Singleton<BondStructureDefinitionCache>.Instance.AddOrUpdateDefinition(def_);
}
else
{
if (pathAlreadySetCorrectly && Items.Any(x => x.Name.Equals(def_.Name)))
return;
// insert item
Items.Add(def_);
OnFolderContentsChanged(new BondStructureFolderChangedArgs(
folder_: this,
addedOrRemovedDefinition_: def_,
action_: CacheAction.StructureAdded));
}
}
internal void applyStructure(BondStructureDefinition structure_)
{
if (structure_ == null) return;
SetNumberOfComponents((uint)structure_.Items.Count);
for (int i = 0; i < structure_.Items.Count; ++i)
{
InternalStructure.Components[i].Bond = BondAnalysisLineHelper.FindBondFromDefinition(structure_.Items[i]);
InternalStructure.Components[i].Multiplier = structure_.Items[i].Multiplier;
}
m_loadedName = structure_.Name;
m_loadedPath = structure_.FolderTree;
tbQuickEntry.Text = string.Empty;
OnGoClicked(EventArgs.Empty);
}
public static async void CreateIntraCountryMaturityGapBondFlies(string[] folderPath_, BondMarket market_, uint unitGap_, MaturityGapUnit unitType_, BondFlyWeightMode mode_)
{
var source = CountryBondSource.GetInstance(market_);
var newDefinitions = new List<BondStructureDefinition>();
foreach (var bond in source.Lines)
{
var idealPriorDate = (unitType_ == MaturityGapUnit.Years)
? bond.Maturity.AddYears(-(int) unitGap_)
: bond.Maturity.AddMonths(-(int) unitGap_);
var priorBond = findBestBond(bond, idealPriorDate, source.Lines, mode_, (int) unitGap_, unitType_);
if (priorBond == null) continue;
var idealLatterDate = (unitType_ == MaturityGapUnit.Years)
? bond.Maturity.AddYears((int) unitGap_)
: bond.Maturity.AddMonths((int) unitGap_);
var latterBond = findBestBond(bond, idealLatterDate, source.Lines, mode_, (int) unitGap_, unitType_);
if (latterBond == null) continue;
var priorWeighting = StructureWeightings.Bfly_Wing;
var latterWeighting = StructureWeightings.Bfly_Wing;
if (mode_ == BondFlyWeightMode.WithinAThirdWeighted)
{
var priorLevel = priorBond.GetValue(BondField.YieldLive);
var level = bond.GetValue(BondField.YieldLive);
var latterLevel = latterBond.GetValue(BondField.YieldLive);
{
var yieldDiff = level - priorLevel;
var maturityDiff = (bond.Maturity - priorBond.Maturity).TotalDays / 365.25d;
var desiredLevel = level - (maturityDiff / Convert.ToDouble(unitGap_) * yieldDiff);
var levelAdjustment = desiredLevel / priorLevel;
priorWeighting *= levelAdjustment;
}
{
var yieldDiff = latterLevel - level;
var maturityDiff = (latterBond.Maturity - bond.Maturity).TotalDays / 365.25d;
var desiredLevel = level + (maturityDiff / Convert.ToDouble(unitGap_) * yieldDiff);
var levelAdjustment = desiredLevel / latterLevel;
latterWeighting *= levelAdjustment;
}
}
var newDef = new BondStructureDefinition()
{
FolderTree = folderPath_,
Items = new System.ComponentModel.BindingList<BondStructureDefinitionItem>(
new[]
{
BondStructureDefinitionItem.GetDefinition(priorBond, priorWeighting),
BondStructureDefinitionItem.GetDefinition(bond, StructureWeightings.Bfly_Belly),
BondStructureDefinitionItem.GetDefinition(latterBond, latterWeighting)
}.ToList()),
Name =
string.Format("{0} {1} {2} {3}{4}", market_, priorBond.Maturity.ToString("MM/yy"),
bond.Maturity.ToString("MM/yy"), latterBond.Maturity.ToString("MM/yy"),
mode_ == BondFlyWeightMode.WithinAThirdWeighted ? " (w)" : string.Empty),
Owner = SymmetryEnvironment.UserName
};
if (!newDefinitions.Any(x => x.Name.Equals(newDef.Name)))
newDefinitions.Add(newDef);
}
await Singleton<BondStructureDefinitionCache>.Instance.AddOrUpdateDefinitions(newDefinitions);
}
