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