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