public Dictionary<YieldCurveKey, Dictionary<string, ValueRequirement>> GetYieldCurveRequirements(RemoteViewClient client, IViewCycle cycle)
        {
            UniqueId clientId = client.GetUniqueId();
            UniqueId cycleId = cycle.UniqueId;

            var createTarget = _rest.Resolve("yieldCurveSpecs", clientId.ToString(), cycleId.ToString());
            return createTarget.Get<Dictionary<YieldCurveKey, Dictionary<string, ValueRequirement>>>();
        }
        public ManageableMarketDataSnapshot CreateSnapshot(RemoteViewClient client, IViewCycle cycle)
        {
            UniqueId clientId = client.GetUniqueId();
            UniqueId cycleId = cycle.UniqueId;

            var createTarget = _rest.Resolve("create", clientId.ToString(), cycleId.ToString());
            return createTarget.Get<ManageableMarketDataSnapshot>();
        }
        public ManageableMarketDataSnapshot CreateSnapshot(RemoteViewClient client, IViewCycle cycle)
        {
            UniqueId clientId = client.GetUniqueId();
            UniqueId cycleId  = cycle.UniqueId;

            var createTarget = _rest.Resolve("create", clientId.ToString(), cycleId.ToString());

            return(createTarget.Get <ManageableMarketDataSnapshot>());
        }
Exemple #4
0
        private static HashSet <Tuple <string, ValueSpecification> > GetAllSpecs(IViewCycle cycle)
        {
            var specSet = new HashSet <Tuple <string, ValueSpecification> >();

            var compiledViewDefinition = cycle.GetCompiledViewDefinition();

            foreach (var kvp in compiledViewDefinition.ViewDefinition.CalculationConfigurationsByName)
            {
                var viewCalculationConfiguration = kvp.Key;

                var dependencyGraphExplorer = compiledViewDefinition.GetDependencyGraphExplorer(viewCalculationConfiguration);
                Assert.NotNull(dependencyGraphExplorer);
                var wholeGraph = dependencyGraphExplorer.GetWholeGraph();

                IEnumerable <ValueSpecification> allSpecs = wholeGraph.DependencyNodes.SelectMany(n => n.OutputValues);
                var distinctKindsOfSpec = allSpecs
                                          .ToLookup(s => s.ValueName).Select(g => g.First());
                var specs = new HashSet <ValueSpecification>(distinctKindsOfSpec);

                if (!specs.Any())
                {
                    continue;
                }
                var computationCacheResponse = cycle.QueryComputationCaches(new ComputationCacheQuery(viewCalculationConfiguration, specs));
                Assert.InRange(computationCacheResponse.Results.Count, 0, specs.Count());
                foreach (var result in computationCacheResponse.Results)
                {
                    Assert.Contains(result.First, specs);
                    Assert.NotNull(result.Second);
                    ValueAssertions.AssertSensibleValue(result.Second);
                }
                var newSpecs = computationCacheResponse.Results.Select(p => Tuple.Create(viewCalculationConfiguration, p.First));
                foreach (var newSpec in newSpecs)
                {
                    Assert.True(specSet.Add(newSpec));
                }
            }

            return(specSet);
        }
        public Dictionary <YieldCurveKey, Dictionary <string, ValueRequirement> > GetYieldCurveRequirements(RemoteViewClient client, IViewCycle cycle)
        {
            UniqueId clientId = client.GetUniqueId();
            UniqueId cycleId  = cycle.UniqueId;

            var createTarget = _rest.Resolve("yieldCurveSpecs", clientId.ToString(), cycleId.ToString());

            return(createTarget.Get <Dictionary <YieldCurveKey, Dictionary <string, ValueRequirement> > >());
        }
        private Dictionary <YieldCurveKey, Tuple <YieldCurve, InterpolatedYieldCurveSpecificationWithSecurities, NodalDoublesCurve> > GetYieldCurves(IViewCycle cycle, IViewComputationResultModel results)
        {
            var ret = new Dictionary <YieldCurveKey, Tuple <YieldCurve, InterpolatedYieldCurveSpecificationWithSecurities, NodalDoublesCurve> >();

            foreach (var kvp in _specs)
            {
                YieldCurveKey key = kvp.Key;
                Dictionary <string, ValueRequirement> specs = kvp.Value;

                var curve        = Get <YieldCurve>(specs[ValueRequirementNames.YieldCurve], results);
                var spec         = Get <InterpolatedYieldCurveSpecificationWithSecurities>(specs[ValueRequirementNames.YieldCurveSpec], results);
                var interpolated = Get <NodalDoublesCurve>(specs[ValueRequirementNames.YieldCurveInterpolated], results);

                if (curve == null || spec == null || interpolated == null)
                {
                    ret.Add(key, null);
                }
                else
                {
                    ret.Add(key, new Tuple <YieldCurve, InterpolatedYieldCurveSpecificationWithSecurities, NodalDoublesCurve>(curve, spec, interpolated));
                }
            }
            return(ret);
        }
        private static HashSet<Tuple<string, ValueSpecification>> GetAllSpecs(IViewCycle cycle)
        {
            var specSet = new HashSet<Tuple<string, ValueSpecification>>();

            var compiledViewDefinition = cycle.GetCompiledViewDefinition();
            foreach (var kvp in compiledViewDefinition.ViewDefinition.CalculationConfigurationsByName)
            {
                var viewCalculationConfiguration = kvp.Key;

                var dependencyGraphExplorer = compiledViewDefinition.GetDependencyGraphExplorer(viewCalculationConfiguration);
                Assert.NotNull(dependencyGraphExplorer);
                var wholeGraph = dependencyGraphExplorer.GetWholeGraph();

                IEnumerable<ValueSpecification> allSpecs = wholeGraph.DependencyNodes.SelectMany(n => n.OutputValues);
                var distinctKindsOfSpec = allSpecs
                    .ToLookup(s => s.ValueName).Select(g => g.First());
                var specs = new HashSet<ValueSpecification>(distinctKindsOfSpec);

                if (!specs.Any())
                {
                    continue;
                }
                var computationCacheResponse = cycle.QueryComputationCaches(new ComputationCacheQuery(viewCalculationConfiguration, specs));
                Assert.InRange(computationCacheResponse.Results.Count, 0, specs.Count());
                foreach (var result in computationCacheResponse.Results)
                {
                    Assert.Contains(result.First, specs);
                    Assert.NotNull(result.Second);
                    ValueAssertions.AssertSensibleValue(result.Second);
                }
                var newSpecs = computationCacheResponse.Results.Select(p => Tuple.Create(viewCalculationConfiguration, p.First));
                foreach (var newSpec in newSpecs)
                {
                    Assert.True(specSet.Add(newSpec));
                }
            }

            return specSet;
        }