/// <summary> /// Creates new session from operation. /// </summary> /// <typeparam name="TSessionState">Session state.</typeparam> /// <param name="operation">Session state operation.</param> /// <param name="getOperations">Get operations function.</param> /// <param name="messages">Optional messages list.</param> /// <returns>New instance of session.</returns> public static ISession <TSessionState> ToSession <TSessionState>( this IOperation <TSessionState> operation, Func <IReadOnlyCollection <IOperation> > getOperations, IMutableMessageList <Message>?messages = null) { return(new LazySession <TSessionState>( sessionOperation: operation, getOperations: getOperations, messages: messages ?? new ConcurrentMessageList <Message>(), executionOptions: null)); }
/// <summary> /// Initializes a new instance of the <see cref="LazySession{TSessionState}"/> class. /// </summary> /// <param name="sessionOperation">Operation that holds operation part of session.</param> /// <param name="messages">Optional messages.</param> /// <param name="getOperations">Optional lazy operations getter.</param> /// <param name="executionOptions">Session execution options.</param> public LazySession( IOperation <TSessionState> sessionOperation, IMutableMessageList <Message> messages, Func <IReadOnlyCollection <IOperation> > getOperations, IExecutionOptions?executionOptions) { Operation = sessionOperation.AssertArgumentNotNull(nameof(sessionOperation)); Messages = messages.AssertArgumentNotNull(nameof(messages)); GetOperations = getOperations.AssertArgumentNotNull(nameof(getOperations)); ExecutionOptions = executionOptions; }
/// <summary> /// Initializes a new instance of the <see cref="MaterializedSession{TSessionState,TOperationState}"/> class. /// </summary> /// <param name="sessionOperation">Session state.</param> /// <param name="messages">Messages.</param> /// <param name="operations">Operations.</param> /// <param name="executionOptions">Session execution options.</param> public MaterializedSession( IOperation <TSessionState> sessionOperation, IMutableMessageList <Message> messages, IReadOnlyCollection <IOperation <TOperationState> > operations, IExecutionOptions?executionOptions) { Operation = sessionOperation.AssertArgumentNotNull(nameof(sessionOperation)); Messages = messages.AssertArgumentNotNull(nameof(messages)); Operations = operations.AssertArgumentNotNull(nameof(operations)); GetOperations = () => Operations; ExecutionOptions = executionOptions; }
/// <summary> /// Copies input <paramref name="context"/> with possible changes. /// </summary> /// <param name="context">Source parser context.</param> /// <param name="parserSettings">Optional parser settings.</param> /// <param name="schema">Optional schema.</param> /// <param name="messages">Optional message list.</param> /// <param name="parsersCache">Optional parsers cache.</param> /// <param name="schemaCache">Optional schemas cache.</param> /// <param name="validatorsCache">Optional validators cache.</param> /// <returns>New <see cref="IXmlParserContext"/> instance.</returns> public static IXmlParserContext With( this IXmlParserContext context, IXmlParserSettings?parserSettings = null, Schema.IMutableObjectSchema?schema = null, IMutableMessageList <Message>?messages = null, ConcurrentDictionary <IProperty, IValueParser>?parsersCache = null, ConcurrentDictionary <IProperty, ISchema>?schemaCache = null, ConcurrentDictionary <IProperty, IPropertyValidationRules>?validatorsCache = null) { context.AssertArgumentNotNull(nameof(context)); return(new XmlParserContext( parserSettings: parserSettings ?? context.ParserSettings, schema: schema ?? context.Schema, messages: messages ?? context.Messages, parsersCache: parsersCache ?? context.ParsersCache, schemaCache: schemaCache ?? context.SchemaCache, validatorsCache: validatorsCache ?? context.ValidatorsCache)); }
/// <summary> /// Initializes a new instance of the <see cref="XmlParserContext"/> class. /// </summary> /// <param name="parserSettings">Parser settings.</param> /// <param name="schema">Schema to use for parsing.</param> /// <param name="messages">Optional message list.</param> /// <param name="parsersCache">Optional parsers cache.</param> /// <param name="schemaCache">Optional schemas cache.</param> /// <param name="validatorsCache">Optional validators cache.</param> public XmlParserContext( IXmlParserSettings parserSettings, ISchema?schema, IMutableMessageList <Message>?messages = null, ConcurrentDictionary <IProperty, IValueParser>?parsersCache = null, ConcurrentDictionary <IProperty, ISchema>?schemaCache = null, ConcurrentDictionary <IProperty, IPropertyValidationRules>?validatorsCache = null) { parserSettings.AssertArgumentNotNull(nameof(parserSettings)); ParserSettings = parserSettings; Schema = schema ?? new MutableObjectSchema(); Messages = messages ?? new MutableMessageList <Message>(); ParsersCache = parsersCache ?? new ConcurrentDictionary <IProperty, IValueParser>(comparer: parserSettings.PropertyComparer); SchemaCache = schemaCache ?? new ConcurrentDictionary <IProperty, ISchema>(comparer: parserSettings.PropertyComparer); ValidatorsCache = validatorsCache ?? new ConcurrentDictionary <IProperty, IPropertyValidationRules>(comparer: parserSettings.PropertyComparer); }
public static IPropertyValue ToModel(this PropertyValueContract propertyValueContract, IMapperSettings mapperSettings, IMutableMessageList <Message>?messages = null) { Type propertyType = mapperSettings.GetTypeByName(propertyValueContract.Type); string propertyName = propertyValueContract.Name; IProperty property = Property.Create(propertyType, propertyName); var propertyValueResult = mapperSettings.DeserializeValue(propertyType, propertyValueContract.Value); object?value = propertyValueResult.GetValueOrDefault(message => { messages?.Add(message); return(null); }); IPropertyValue propertyValue = PropertyValue.Create(property, value: value, valueSource: propertyValueResult.IsSuccess ? ValueSource.Defined : ValueSource.NotDefined); return(propertyValue); }