Beispiel #1
0
 public ActionMetadata(MethodInfo action, ParameterMetadata[] parameters, int cancellationTokenIndex, Type resultType, bool hasSerializableParameters)
 {
     Action = action;
     Parameters = parameters;
     CancellationTokenIndex = cancellationTokenIndex;
     ResultType = resultType;
     HasSerializableParameters = hasSerializableParameters;
 }
 protected AbstractQueryImpl(string queryString, FlushMode flushMode, ISessionImplementor session,
                             ParameterMetadata parameterMetadata)
 {
     this.session           = session;
     this.queryString       = queryString;
     selection              = new RowSelection();
     this.flushMode         = flushMode;
     cacheMode              = null;
     this.parameterMetadata = parameterMetadata;
 }
        public virtual void test_metadata_end()
        {
            OvernightIborSwapCurveNode node = OvernightIborSwapCurveNode.of(TEMPLATE, QUOTE_ID, SPREAD);
            LocalDate         valuationDate = LocalDate.of(2015, 1, 22);
            ParameterMetadata metadata      = node.metadata(valuationDate, REF_DATA);

            // 2015-01-22 is Thursday, start is 2015-01-26, but 2025-01-26 is Sunday, so end is 2025-01-27
            assertEquals(((TenorDateParameterMetadata)metadata).Date, LocalDate.of(2025, 1, 27));
            assertEquals(((TenorDateParameterMetadata)metadata).Tenor, Tenor.TENOR_10Y);
        }
Beispiel #4
0
            public override ParameterState Parse(ParameterMetadata parameter)
            {
                switch (parameter.Kind)
                {
                case ParameterKind.KeyRest: UpdateWith(parameter); return(this);

                case ParameterKind.Block:   return(ParseInfoWith <BlockState>(parameter));

                default: return(InvalidParameterError(parameter));
                }
            }
Beispiel #5
0
        public Parameter(ParameterMetadata meta)
        {
            _name = meta.Name;

            if (meta.SwitchParameter)
            {
                ParamMode = ParameterMode.Switch;
            }

            _paramType = meta.ParameterType;
        }
 public static ParameterBaseDTO ToBaseDTO(this ParameterMetadata metadata)
 {
     if (metadata == null)
     {
         return(null);
     }
     return(new ParameterBaseDTO
     {
         Name = metadata.Name,
         TypeMetadata = metadata.TypeMetadata.ToBaseDTO()
     });
 }
        public List <ExternalRule> GetExternalRule(string[] moduleNames)
        {
            List <ExternalRule> rules = new List <ExternalRule>();

            if (moduleNames == null)
            {
                return(rules);
            }

            // Converts module path to module name.
            foreach (string moduleName in moduleNames)
            {
                string shortModuleName = string.Empty;

                // Imports modules by using full path.
                InitialSessionState state = InitialSessionState.CreateDefault2();
                state.ImportPSModule(new string[] { moduleName });

                using (System.Management.Automation.PowerShell posh =
                           System.Management.Automation.PowerShell.Create(state))
                {
                    string script = string.Format(CultureInfo.CurrentCulture, "Get-Module -Name '{0}' -ListAvailable", moduleName);
                    shortModuleName = posh.AddScript(script).Invoke <PSModuleInfo>().First().Name;

                    // Invokes Get-Command and Get-Help for each functions in the module.
                    script = string.Format(CultureInfo.CurrentCulture, "Get-Command -Module '{0}'", shortModuleName);
                    var psobjects = posh.AddScript(script).Invoke();

                    foreach (PSObject psobject in psobjects)
                    {
                        posh.Commands.Clear();

                        FunctionInfo      funcInfo = (FunctionInfo)psobject.ImmediateBaseObject;
                        ParameterMetadata param    = funcInfo.Parameters.Values
                                                     .First <ParameterMetadata>(item => item.Name.ToLower(CultureInfo.CurrentCulture).EndsWith("ast", StringComparison.CurrentCulture) ||
                                                                                item.Name.ToLower(CultureInfo.CurrentCulture).EndsWith("token", StringComparison.CurrentCulture));

                        //Only add functions that are defined as rules.
                        if (param != null)
                        {
                            script = string.Format(CultureInfo.CurrentCulture, "(Get-Help -Name {0}).Description | Out-String", funcInfo.Name);
                            string desc = posh.AddScript(script).Invoke()[0].ImmediateBaseObject.ToString()
                                          .Replace("\r\n", " ").Trim();

                            rules.Add(new ExternalRule(funcInfo.Name, funcInfo.Name, desc, param.Name,
                                                       funcInfo.ModuleName, funcInfo.Module.Path));
                        }
                    }
                }
            }

            return(rules);
        }
        internal ParameterMetadata GetParameterMetadata(ParameterModel parameterModel, Type serializerType)
        {
            var rpcParams     = Utils.GetAttribute <FromParamsAttribute>(parameterModel)?.BindingStyle ?? BindingStyle.Default;
            var serializer    = Utils.GetSerializer(serializers, serializerType);
            var parameterName = serializer.GetJsonName(parameterModel.ParameterName);
            // TODO use RequiredAttribute?
            var isOptional = parameterModel.ParameterInfo.IsOptional; // see https://stackoverflow.com/q/9977530/
            var result     = new ParameterMetadata(parameterName, parameterModel.ParameterType, parameterModel.ParameterInfo.Position, rpcParams, isOptional);

            log.LogTrace($"{parameterModel.DisplayName}: metadata [{result}]");
            return(result);
        }
 public ParameterMetadata MapUp(BaseParameterMetadata model)
 {
     ParameterMetadata parameterModel = new ParameterMetadata();
     parameterModel.Name = model.Name;
     Type type = model.GetType();
     PropertyInfo typeProperty = type.GetProperty("Type", 
         BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
     BaseTypeMetadata typeModel = (BaseTypeMetadata)typeProperty?.GetValue(model);
     if (typeModel != null)
         parameterModel.Type = TypeModelMapper.EmitType(typeModel);
     return parameterModel;
 }
Beispiel #10
0
        public ParameterMetadataBase MapToSerialize(ParameterMetadata metadata, Type parameterMetadataType)
        {
            object       parameterMetadata = Activator.CreateInstance(parameterMetadataType);
            PropertyInfo nameProperty      = parameterMetadataType.GetProperty("Name");
            PropertyInfo typeProperty      = parameterMetadataType.GetProperty("TypeMetadata", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);

            nameProperty?.SetValue(parameterMetadata, metadata.Name);
            if (metadata.TypeMetadata != null)
            {
                typeProperty?.SetValue(parameterMetadata, typeProperty.PropertyType.Cast(TypeMetadataMapper.EmitTypeToSerialization(metadata.TypeMetadata, typeProperty.PropertyType)));
            }
            return((ParameterMetadataBase)parameterMetadata);
        }
 public void Init(string value, bool overriden, ParameterMetadata parameterMetadata, string objectId, bool updateEnabled, VerticalLayoutGroup layoutGroupToBeDisabled, GameObject canvasRoot)
 {
     LayoutGroupToBeDisabled = layoutGroupToBeDisabled;
     CanvasRoot = canvasRoot;
     SaveBtn.gameObject.SetActive(false);
     this.parameterMetadata = parameterMetadata;
     this.objectId          = objectId;
     SetValue(value, overriden);
     SaveBtn.SetInteractivity(updateEnabled, "Modification could only be done when offline");
     ModifyBtn.SetInteractivity(updateEnabled, "Modification could only be done when offline");
     RestoreBtn.SetInteractivity(updateEnabled, "Modification could only be done when offline");
     CancelBtn.SetInteractivity(updateEnabled, "Modification could only be done when offline");
 }
        public BaseParameterMetadata MapDown(ParameterMetadata model, Type parameterModelType)
        {
            object parameterModel = Activator.CreateInstance(parameterModelType);
            PropertyInfo nameProperty = parameterModelType.GetProperty("Name");
            PropertyInfo typeProperty = parameterModelType.GetProperty("Type",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
            nameProperty?.SetValue(parameterModel, model.Name);
            if (model.Type != null)
                typeProperty?.SetValue(parameterModel, 
                    typeProperty.PropertyType.Cast(TypeModelMapper.EmitBaseType(model.Type, typeProperty.PropertyType)));

            return (BaseParameterMetadata)parameterModel;
        }
Beispiel #13
0
        public virtual void test_metadata_end()
        {
            IborFutureCurveNode node          = IborFutureCurveNode.of(TEMPLATE, QUOTE_ID, SPREAD, LABEL);
            LocalDate           date          = LocalDate.of(2015, 10, 20);
            LocalDate           referenceDate = TEMPLATE.calculateReferenceDateFromTradeDate(date, REF_DATA);
            LocalDate           maturityDate  = TEMPLATE.Index.calculateMaturityFromEffective(referenceDate, REF_DATA);
            ParameterMetadata   metadata      = node.metadata(date, REF_DATA);

            assertEquals(metadata.Label, LABEL);
            assertTrue(metadata is YearMonthDateParameterMetadata);
            assertEquals(((YearMonthDateParameterMetadata)metadata).Date, maturityDate);
            assertEquals(((YearMonthDateParameterMetadata)metadata).YearMonth, YearMonth.from(referenceDate));
        }
        public void Test_ParseParams_CallsParseArray()
        {
            var expected          = Mock.Of <IParseResult>();
            var parameterMetadata = new ParameterMetadata(new JsonName("test", "test"), typeof(object), 0, BindingStyle.Default, false);

            paramsParserMock.Setup(x => x.ParseArray(It.IsAny <JArray>(), It.IsAny <int>(), It.IsAny <BindingStyle>()))
            .Returns(expected);

            var result = paramsParserMock.Object.ParseParams(new JArray(), parameterMetadata);

            result.Should().Be(expected);
            paramsParserMock.Verify(x => x.ParseArray(It.IsAny <JArray>(), It.IsAny <int>(), It.IsAny <BindingStyle>()));
            paramsParserMock.VerifyNoOtherCalls();
        }
 /*********
 ** Public methods
 *********/
 /// <summary>Get an error message indicating why the usage is invalid (or <c>null</c> if usage is valid).</summary>
 /// <param name="parameter">Represents a parameter annotated by a single contract annotation.</param>
 public string GetError(ParameterMetadata parameter)
 {
     if (!this.IsAllowedType(parameter.ParameterQualifiedType, parameter.ParameterTypeIsUnknown))
     {
         return String.Format(
             "This annotation is used incorrectly and will be ignored: {0} on the {1}::{2}({3}) parameter. The contract is only compatible with reference types.",
             parameter.Annotation.GetType(),
             parameter.TypeName,
             parameter.MethodName,
             parameter.Name
         );
     }
     return null;
 }
Beispiel #16
0
        //-------------------------------------------------------------------------
        private static ImmutableList <ParameterMetadata> createParameterMetadata(double expiry, DoubleArray delta)
        {
            ArgChecker.notNull(delta, "delta");
            int nbDelta = delta.size();

            ParameterMetadata[] parameterMetadata = new ParameterMetadata[2 * nbDelta + 1];
            parameterMetadata[nbDelta] = GenericVolatilitySurfaceYearFractionParameterMetadata.of(expiry, DeltaStrike.of(0.5d));
            for (int i = 0; i < nbDelta; i++)
            {
                parameterMetadata[i] = GenericVolatilitySurfaceYearFractionParameterMetadata.of(expiry, DeltaStrike.of(1d - delta.get(i)));          // Put
                parameterMetadata[2 * nbDelta - i] = GenericVolatilitySurfaceYearFractionParameterMetadata.of(expiry, DeltaStrike.of(delta.get(i))); // Call
            }
            return(ImmutableList.copyOf(parameterMetadata));
        }
        public virtual void parSpreadTest()
        {
            LocalDate   valuationDate    = LocalDate.of(2013, 2, 27);
            DoubleArray ycTime           = DoubleArray.ofUnsafe(new double[] { 0.09041095890410959, 0.1726027397260274, 0.26301369863013696, 0.5123287671232877, 0.7616438356164383, 1.010958904109589, 2.008219178082192, 3.008219178082192, 4.008219178082192, 5.008219178082192, 6.008219178082192, 7.013698630136987, 8.01095890410959, 9.01095890410959, 10.01095890410959, 12.01917808219178, 15.016438356164384, 20.01917808219178, 25.021917808219175, 30.027397260273972 });
            DoubleArray ycRate           = DoubleArray.ofUnsafe(new double[] { 0.0020651105531615476, 0.0024506037920717797, 0.0028872269869485313, 0.004599628230463427, 0.006160809466806469, 0.0075703969168129295, 0.003965128877560435, 0.005059104202201957, 0.0069669135253734825, 0.009361825469323602, 0.011916895611422482, 0.014311922779901886, 0.016519187063048578, 0.018512121993907647, 0.020289623737560873, 0.02329885162861984, 0.026399509889410745, 0.029087919732133784, 0.03037740056662963, 0.03110021763406523 });
            IsdaCreditDiscountFactors yc = IsdaCreditDiscountFactors.of(EUR, valuationDate, CurveName.of("yc_usd"), ycTime, ycRate, ACT_365F);

            double[] timeNodeExp   = new double[] { 0.5616438356164384, 1.0575342465753426, 2.0575342465753423, 3.0602739726027397, 4.06027397260274, 5.06027397260274, 6.06027397260274, 7.063013698630137, 8.063013698630137, 9.063013698630137, 10.063013698630137 };
            double[] rateNodeExp   = new double[] { 0.00876054089781935, 0.011037345646850688, 0.015955126945240167, 0.020617953392829177, 0.025787811343896218, 0.030329992053915133, 0.03313419899444371, 0.03528129159875671, 0.03675340516560903, 0.037946169956317416, 0.038951101800190346 };
            double[] rateNodeExpMf = new double[] { 0.008754510260229803, 0.011030502992814844, 0.01594817866773906, 0.02060947097554756, 0.025776720596175737, 0.030316032527460755, 0.03311839631615255, 0.03526404051997617, 0.03673513322394772, 0.03792689865945585, 0.03893107891569398 };
            ImmutableCreditRatesProvider ratesProvider = ImmutableCreditRatesProvider.builder().valuationDate(valuationDate).discountCurves(ImmutableMap.of(EUR, yc)).recoveryRateCurves(ImmutableMap.of(LEGAL_ENTITY, ConstantRecoveryRates.of(LEGAL_ENTITY, valuationDate, 0.25))).creditCurves(ImmutableMap.of()).build();
            LocalDate startDate = LocalDate.of(2012, 12, 20);

            LocalDate[] pillarDates = new LocalDate[] { LocalDate.of(2013, 9, 20), LocalDate.of(2014, 3, 20), LocalDate.of(2015, 3, 20), LocalDate.of(2016, 3, 20), LocalDate.of(2017, 3, 20), LocalDate.of(2018, 3, 20), LocalDate.of(2019, 3, 20), LocalDate.of(2020, 3, 20), LocalDate.of(2021, 3, 20), LocalDate.of(2022, 3, 20), LocalDate.of(2023, 3, 20) };
            int         nPillars    = pillarDates.Length;
            ImmutableMarketDataBuilder     builderCredit = ImmutableMarketData.builder(valuationDate);
            IList <CdsIsdaCreditCurveNode> nodes         = new List <CdsIsdaCreditCurveNode>(nPillars);

            double[] quotes = new double[] { 0.006485, 0.008163, 0.011763, 0.015136, 0.018787, 0.021905, 0.023797, 0.025211, 0.02617, 0.026928, 0.027549 };
            for (int i = 0; i < nPillars; ++i)
            {
                CdsConvention conv = ImmutableCdsConvention.of("conv", EUR, ACT_360, Frequency.P3M, BUS_ADJ, CDS_SETTLE_STD);
                CdsTemplate   temp = DatesCdsTemplate.of(startDate, pillarDates[i], conv);
                QuoteId       id   = QuoteId.of(StandardId.of("OG", pillarDates[i].ToString()));
                nodes.Add(CdsIsdaCreditCurveNode.ofParSpread(temp, id, LEGAL_ENTITY));
                builderCredit.addValue(id, quotes[i]);
            }
            ImmutableMarketData              marketData      = builderCredit.build();
            IsdaCreditCurveDefinition        curveDefinition = IsdaCreditCurveDefinition.of(CurveName.of("zz"), EUR, valuationDate, ACT_365F, nodes, true, true);
            LegalEntitySurvivalProbabilities cc = BUILDER_ISDA.calibrate(curveDefinition, marketData, ratesProvider, REF_DATA);
            NodalCurve resCurve = ((IsdaCreditDiscountFactors)cc.SurvivalProbabilities).Curve;

            for (int i = 0; i < nPillars; ++i)
            {
                ParameterMetadata param = resCurve.getParameterMetadata(i);
                assertTrue(param is ResolvedTradeParameterMetadata);
                ResolvedTradeParameterMetadata tradeParam = (ResolvedTradeParameterMetadata)param;
                assertTrue(tradeParam.Trade is ResolvedCdsTrade);
            }
            assertTrue(DoubleArrayMath.fuzzyEquals(resCurve.XValues.toArray(), timeNodeExp, TOL));
            assertTrue(DoubleArrayMath.fuzzyEquals(resCurve.YValues.toArray(), rateNodeExp, TOL));
            testJacobian(BUILDER_ISDA, cc, ratesProvider, nodes, quotes, 1d, EPS);
            LegalEntitySurvivalProbabilities ccMf = BUILDER_MARKIT.calibrate(curveDefinition, marketData, ratesProvider, REF_DATA);
            NodalCurve resCurveMf = ((IsdaCreditDiscountFactors)ccMf.SurvivalProbabilities).Curve;

            assertTrue(DoubleArrayMath.fuzzyEquals(resCurveMf.XValues.toArray(), timeNodeExp, TOL));
            assertTrue(DoubleArrayMath.fuzzyEquals(resCurveMf.YValues.toArray(), rateNodeExpMf, TOL));
            testJacobian(BUILDER_MARKIT, ccMf, ratesProvider, nodes, quotes, 1d, EPS);
        }
        protected override StructureMetadata LoadStructureMetadata(string structureName)
        {
            string xpath = string.Format("//xsd:complexType[@name='{0}']/xsd:sequence/xsd:element", structureName);
            var    nodes = this.responseXml.SelectNodes(xpath, this.nsmgr);

            List <FieldMetadata> fields = new List <FieldMetadata>();

            foreach (XmlNode node in nodes)
            {
                ParameterMetadata param = this.ExtractParameterFromXmlNode(node);
                fields.Add(new FieldMetadata(param.Name, param.DataType));
            }

            return(new StructureMetadata(structureName, fields));
        }
Beispiel #19
0
            public override ParameterState Parse(ParameterMetadata parameter)
            {
                switch (parameter.Kind)
                {
                case ParameterKind.KeyRequired: ParameterCounter.KeyRequired++; return(this);

                case ParameterKind.KeyOptional: ParameterCounter.KeyOptional++; return(this);

                case ParameterKind.KeyRest:     return(ParseInfoWith <KeyRestState>(parameter));

                case ParameterKind.Block:       return(ParseInfoWith <BlockState>(parameter));

                default: return(InvalidParameterError(parameter));
                }
            }
Beispiel #20
0
        //-------------------------------------------------------------------------
        public virtual void test_withNode_atStart_withMetadata()
        {
            InterpolatedNodalCurve     @base = InterpolatedNodalCurve.of(METADATA_ENTRIES, XVALUES, YVALUES, INTERPOLATOR);
            LabelDateParameterMetadata item  = LabelDateParameterMetadata.of(date(2015, 6, 30), TNR_1Y);
            InterpolatedNodalCurve     test  = @base.withNode(0.5d, 4d, item);
            IList <ParameterMetadata>  list  = new List <ParameterMetadata>();

            list.Add(item);
            ((IList <ParameterMetadata>)list).AddRange(ParameterMetadata.listOfEmpty(SIZE));
            assertThat(test.Name).isEqualTo(CURVE_NAME);
            assertThat(test.ParameterCount).isEqualTo(SIZE + 1);
            assertThat(test.Metadata).isEqualTo(METADATA_ENTRIES.withParameterMetadata(list));
            assertThat(test.XValues).isEqualTo(DoubleArray.of(0.5d, 1d, 2d, 3d));
            assertThat(test.YValues).isEqualTo(DoubleArray.of(4d, 5d, 7d, 8d));
        }
Beispiel #21
0
        private static                                 Marshaller[] InitializeMarshallers(MethodDesc targetMethod, InteropStateManager interopStateManager, PInvokeFlags flags)
        {
            bool             isDelegate = targetMethod is DelegateMarshallingMethodThunk;
            MethodSignature  methodSig  = isDelegate ? ((DelegateMarshallingMethodThunk)targetMethod).DelegateSignature : targetMethod.Signature;
            MarshalDirection direction  = isDelegate ? ((DelegateMarshallingMethodThunk)targetMethod).Direction: MarshalDirection.Forward;
            int indexOffset             = 0;

            if (!methodSig.IsStatic && direction == MarshalDirection.Forward)
            {
                // For instance methods(eg. Forward delegate marshalling thunk), first argument is
                // the instance
                indexOffset = 1;
            }
            ParameterMetadata[] parameterMetadataArray = targetMethod.GetParameterMetadata();
            Marshaller[]        marshallers            = new Marshaller[methodSig.Length + 1];
            int parameterIndex = 0;
            ParameterMetadata parameterMetadata;

            for (int i = 0; i < marshallers.Length; i++)
            {
                Debug.Assert(parameterIndex == parameterMetadataArray.Length || i <= parameterMetadataArray[parameterIndex].Index);
                if (parameterIndex == parameterMetadataArray.Length || i < parameterMetadataArray[parameterIndex].Index)
                {
                    // if we don't have metadata for the parameter, create a dummy one
                    parameterMetadata = new ParameterMetadata(i, ParameterMetadataAttributes.None, null);
                }
                else
                {
                    Debug.Assert(i == parameterMetadataArray[parameterIndex].Index);
                    parameterMetadata = parameterMetadataArray[parameterIndex++];
                }
                TypeDesc parameterType = (i == 0) ? methodSig.ReturnType : methodSig[i - 1];  //first item is the return type
                marshallers[i] = Marshaller.CreateMarshaller(parameterType,
                                                             MarshallerType.Argument,
                                                             parameterMetadata.MarshalAsDescriptor,
                                                             direction,
                                                             marshallers,
                                                             interopStateManager,
                                                             indexOffset + parameterMetadata.Index,
                                                             flags,
                                                             parameterMetadata.In,
                                                             parameterMetadata.Out,
                                                             parameterMetadata.Return
                                                             );
            }

            return(marshallers);
        }
        public virtual void test_builder_noParamMetadata()
        {
            ParameterizedFunctionalCurveDefinition test = ParameterizedFunctionalCurveDefinition.builder().dayCount(ACT_365F).valueFunction(VALUE_FUNCTION).derivativeFunction(DERIVATIVE_FUNCTION).sensitivityFunction(SENSITIVITY_FUNCTION).initialGuess(INITIAL_PARAMS).name(CURVE_NAME).nodes(NODES).xValueType(ValueType.YEAR_FRACTION).yValueType(ValueType.ZERO_RATE).build();

            assertEquals(test.Name, CURVE_NAME);
            assertEquals(test.XValueType, ValueType.YEAR_FRACTION);
            assertEquals(test.YValueType, ValueType.ZERO_RATE);
            assertEquals(test.DayCount, ACT_365F);
            assertEquals(test.Nodes, NODES);
            assertEquals(test.ValueFunction, VALUE_FUNCTION);
            assertEquals(test.DerivativeFunction, DERIVATIVE_FUNCTION);
            assertEquals(test.SensitivityFunction, SENSITIVITY_FUNCTION);
            assertEquals(test.InitialGuess, INITIAL_PARAMS);
            assertEquals(test.ParameterCount, 3);
            assertEquals(test.ParameterMetadata, ParameterMetadata.listOfEmpty(3));
        }
Beispiel #23
0
        public static ParameterMetadata ToMetadata(this IParameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            var parameterMetadata = new ParameterMetadata()
            {
                Value    = parameter.GetValue(),
                Operator = parameter.Operator.ToMetadata(),
                Id       = parameter.Id
            };

            return(parameterMetadata);
        }
        private double shiftForNode(int scenarioIndex, ParameterMetadata meta)
        {
            int?nodeIndex = nodeIndices.get(meta.Identifier);

            if (nodeIndex != null)
            {
                return(shifts.get(scenarioIndex, nodeIndex.Value));
            }
            nodeIndex = nodeIndices.get(meta.Label);

            if (nodeIndex != null)
            {
                return(shifts.get(scenarioIndex, nodeIndex.Value));
            }
            return(0);
        }
        public ParameterMetadata MapUp(ParameterModel model)
        {
            ParameterMetadata ParameterMetadata = new ParameterMetadata();

            ParameterMetadata.Name = model.Name;
            Type         type         = model.GetType();
            PropertyInfo typeProperty = type.GetProperty("Type",
                                                         BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
            TypeModel typeModel = (TypeModel)typeProperty?.GetValue(model);

            if (typeModel != null)
            {
                ParameterMetadata.TypeMetadata = TypeModelMapper.EmitType(typeModel);
            }
            return(ParameterMetadata);
        }
Beispiel #26
0
        public ParameterMetadata MapToDeserialize(ParameterMetadataBase metadata)
        {
            ParameterMetadata parameterMetadata = new ParameterMetadata
            {
                Name = metadata.Name
            };
            Type             type         = metadata.GetType();
            PropertyInfo     typeProperty = type.GetProperty("TypeMetadata", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
            TypeMetadataBase typeModel    = (TypeMetadataBase)typeProperty?.GetValue(metadata);

            if (typeModel != null)
            {
                parameterMetadata.TypeMetadata = TypeMetadataMapper.EmitTypeForDeserialization(typeModel);
            }
            return(parameterMetadata);
        }
        public ParameterModel MapDown(ParameterMetadata model, Type ParameterMetadataType)
        {
            object       ParameterMetadata = Activator.CreateInstance(ParameterMetadataType);
            PropertyInfo nameProperty      = ParameterMetadataType.GetProperty("Name");
            PropertyInfo typeProperty      = ParameterMetadataType.GetProperty("Type",
                                                                               BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);

            nameProperty?.SetValue(ParameterMetadata, model.Name);
            if (model.TypeMetadata != null)
            {
                typeProperty?.SetValue(ParameterMetadata,
                                       typeProperty.PropertyType.Cast(TypeModelMapper.EmitBaseType(model.TypeMetadata, typeProperty.PropertyType)));
            }

            return((ParameterModel)ParameterMetadata);
        }
        private int _maxResults = 20;  //Environment.MaxResults;

        #region Constructors

        /// <summary>
        /// classes must be immutable
        /// </summary>
        public FullTextQueryImpl(Lucene.Net.Search.Query query,
                                 System.Type[] classes,
                                 ISession session,
                                 ParameterMetadata parameterMetadata,
                                 INHibernateLogger log = null)
            : base(query?.ToString() ?? throw new ArgumentNullException(nameof(query)),
                   FlushMode.Unspecified,
                   session?.GetSessionImplementation() ?? throw new ArgumentNullException(nameof(session)),
                   parameterMetadata) // ?? throw new ArgumentNullException(nameof(parameterMetadata)))
        {
            this.log               = log ?? NHibernateLogger.For(typeof(FullTextQueryImpl));
            luceneQuery            = query;
            resultSize             = -1;
            this.classes           = classes;
            this.filterDefinitions = new Dictionary <string, FullTextFilterImpl>();
        }
Beispiel #29
0
        // extract CDS index trades from credit curve
        private ImmutableList <ResolvedCdsIndexTrade> getBucketCdsIndex(ResolvedCdsIndex product, CreditRatesProvider ratesProvider)
        {
            CreditDiscountFactors creditCurve = ratesProvider.survivalProbabilities(product.CdsIndexId, product.Currency).SurvivalProbabilities;
            int nNodes = creditCurve.ParameterCount;

            ImmutableList.Builder <ResolvedCdsIndexTrade> builder = ImmutableList.builder();
            for (int i = 0; i < nNodes; ++i)
            {
                ParameterMetadata metadata = creditCurve.getParameterMetadata(i);
                ArgChecker.isTrue(metadata is ResolvedTradeParameterMetadata, "ParameterMetadata of credit curve must be ResolvedTradeParameterMetadata");
                ResolvedTradeParameterMetadata tradeMetadata = (ResolvedTradeParameterMetadata)metadata;
                ResolvedTrade trade = tradeMetadata.Trade;
                ArgChecker.isTrue(trade is ResolvedCdsIndexTrade, "ResolvedTrade must be ResolvedCdsIndexTrade");
                builder.add((ResolvedCdsIndexTrade)trade);
            }
            return(builder.build());
        }
Beispiel #30
0
        //-------------------------------------------------------------------------
        public virtual void test_basics()
        {
            ParameterizedDataCombiner test = ParameterizedDataCombiner.of(DATA1, DATA2, DATA3);

            assertEquals(test.ParameterCount, 5);
            assertEquals(test.getParameter(0), 1d);
            assertEquals(test.getParameter(1), 2d);
            assertEquals(test.getParameter(2), 3d);
            assertEquals(test.getParameter(3), 4d);
            assertEquals(test.getParameter(4), 5d);
            assertEquals(test.getParameterMetadata(0), ParameterMetadata.empty());
            assertThrows(() => test.getParameter(-1), typeof(System.IndexOutOfRangeException));
            assertThrows(() => test.getParameter(5), typeof(System.IndexOutOfRangeException));
            assertThrows(() => test.getParameterMetadata(-1), typeof(System.IndexOutOfRangeException));
            assertThrows(() => test.getParameterMetadata(5), typeof(System.IndexOutOfRangeException));
            assertThrowsIllegalArg(() => ParameterizedDataCombiner.of());
        }
Beispiel #31
0
        protected override FunctionMetadata LoadFunctionMetadata(string functionName)
        {
            var remoteFunctionMetadata = this.connection.Repository.GetFunctionMetadata(functionName);

            List <ParameterMetadata> inputParameters  = new List <ParameterMetadata>();
            List <ParameterMetadata> outputParameters = new List <ParameterMetadata>();

            for (int i = 0; i < remoteFunctionMetadata.ParameterCount; i++)
            {
                StructureMetadata structureMetadata = null;
                if (remoteFunctionMetadata[i].DataType == RfcDataType.STRUCTURE)
                {
                    string structureName = remoteFunctionMetadata[i].ValueMetadataAsStructureMetadata.Name;
                    structureMetadata = this.GetStructureMetadata(structureName);
                }
                else if (remoteFunctionMetadata[i].DataType == RfcDataType.STRUCTURE)
                {
                    string structureName = remoteFunctionMetadata[i].ValueMetadataAsTableMetadata.LineType.Name;
                    structureMetadata = this.GetStructureMetadata(structureName);
                }

                var parameter = new ParameterMetadata(remoteFunctionMetadata[i].Name, remoteFunctionMetadata[i].GetAbapDataType(), structureMetadata);
                switch (remoteFunctionMetadata[i].Direction)
                {
                case RfcDirection.EXPORT:
                    outputParameters.Add(parameter);
                    break;

                case RfcDirection.IMPORT:
                    inputParameters.Add(parameter);
                    break;

                case RfcDirection.TABLES:
                case RfcDirection.CHANGING:
                    inputParameters.Add(parameter);
                    outputParameters.Add(parameter);
                    break;

                default:
                    break;
                }
            }

            return(new FunctionMetadata(functionName, inputParameters, outputParameters));
        }
Beispiel #32
0
        public void Test_BindModelAsync_UsesParserAndBinder()
        {
            var jsonRpcMethodOptions = new JsonRpcMethodOptions();
            var methodMetadata       = new MethodMetadata(jsonRpcMethodOptions, new JsonName("test", "test"), new JsonName("test", "test"));
            var parameterMetadata    = new ParameterMetadata(new JsonName("test", "test"), typeof(object), 0, BindingStyle.Default, false);

            methodMetadata.Add(parameterMetadata);
            var name = "test";
            var bindingContextMock = MockContext(methodMetadata: methodMetadata, name: name);
            var binder             = testEnvironment.ServiceProvider.GetRequiredService <JsonRpcModelBinder>();

            binder.BindModelAsync(bindingContextMock.Object).GetAwaiter().GetResult();

            Mock.Get(testEnvironment.ServiceProvider.GetService <IParamsParser>())
            .Verify(x => x.ParseParams(It.IsAny <JToken>(), parameterMetadata), Times.Once);
            Mock.Get(testEnvironment.ServiceProvider.GetService <IParameterBinder>())
            .Verify(x => x.SetResult(bindingContextMock.Object, It.IsAny <IParseResult>(), name, It.IsAny <JsonRpcBindingContext>()), Times.Once);
        }
        /// <summary>
        /// Get cmdlets from the given assembly
        /// </summary>
        /// <param name="assemblyPath"></param>
        /// <returns></returns>
        public IList<CmdletSignatureMetadata> GetCmdlets(string assemblyPath)
        {
            IList<CmdletSignatureMetadata> result = new List<CmdletSignatureMetadata>();
            try
            {
                var assembly = Assembly.LoadFrom(assemblyPath);
                foreach (var type in assembly.GetCmdletTypes())
                {
                    var cmdlet = type.GetAttribute<CmdletAttribute>();
                    var outputs = type.GetAttributes<OutputTypeAttribute>();
                    var parameters = type.GetParameters();

                    var cmdletMetadata = new CmdletSignatureMetadata
                    {
                        VerbName = cmdlet.VerbName,
                        NounName = cmdlet.NounName,
                        ConfirmImpact = cmdlet.ConfirmImpact,
                        SupportsShouldProcess = cmdlet.SupportsShouldProcess,
                        ClassName = type.FullName,
                        AssemblyName = assembly.FullName
                    };
                    foreach (var output in outputs)
                    {
                        foreach (var outputType in output.Type)
                        {
                            var outputMetadata = new OutputMetadata
                            {
                                Type = outputType.Type
                            };
                            outputMetadata.ParameterSets.AddRange(output.ParameterSetName);
                        }
                    }

                    foreach (var parameter in parameters)
                    {
                        if ( parameter.Name == "Force" && parameter.PropertyType == typeof (SwitchParameter))
                        {
                            cmdletMetadata.HasForceSwitch = true;
                        }

                        var parameterData = new ParameterMetadata
                        {
                            Type = parameter.PropertyType,
                            Name = parameter.Name
                        };
                        if (parameter.HasAttribute<AliasAttribute>())
                        {
                            var aliases = parameter.GetAttributes<AliasAttribute>();
                            parameterData.AliasList.AddRange(
                                aliases.SelectMany(a => a.AliasNames));
                        }

                        cmdletMetadata.Parameters.Add(parameterData);
                    }

                    result.Add(cmdletMetadata);
                }
            }
            catch
            {
            }

            return result;
        }
        private static IEnumerable<ParameterMetadata> GetRouteParameters(ServiceMethodMetadata metadata, IProxyMetadata proxyMetadata)
        {
            var routeParameters = new List<ParameterMetadata>();

            foreach (ParameterInfo parameter in metadata.MethodInfo.GetParameters())
            {
                if (metadata.UrlInfo.UrlTemplate.IndexOf(String.Concat("{", parameter.Name, "}"), StringComparison.OrdinalIgnoreCase) < 0)
                {
                    continue;
                }

                ParameterMetadata parameterMetadata = proxyMetadata != null ?
                                                                proxyMetadata.GetParameter(metadata.MethodInfo, parameter.Name, RequestParameterType.Route) :
                                                                null;

                var routeParameter = new ParameterMetadata
                {
                    Name = parameter.Name.ToLowerInvariant(),
                    ParameterType = RequestParameterType.Route,
                    Type = parameter.ParameterType,
                    IsOptionalParameter = parameter.DefaultValue != DBNull.Value,
                    RegexConstraint = GetParameterConstraint(parameter),
                    ExampleValue = parameterMetadata != null ? parameterMetadata.ExampleValue : null,
                    AllowedValues = parameterMetadata != null ? parameterMetadata.AllowedValues : null
                };

                routeParameters.Add(routeParameter);
            }

            return routeParameters;
        }