/// <summary> /// Initializes a new instance of the <see cref="BackingStoreParseNodeFactory"/> class given a concrete implementation of <see cref="IParseNodeFactory"/>. /// </summary> public BackingStoreParseNodeFactory(IParseNodeFactory concrete) : base( concrete, (x) => { if (x is IBackedModel backedModel && backedModel.BackingStore != null) { backedModel.BackingStore.InitializationCompleted = false; }
/// <summary> /// Initializes a new instance of the <see cref="HttpCore"/> class. /// <param name="authProvider">The authentication provider.</param> /// <param name="pNodeFactory">The parse node factory.</param> /// <param name="sWriterFactory">The serialization writer factory.</param> /// <param name="client">The native HTTP client.</param> /// </summary> public HttpCore(IAuthenticationProvider authenticationProvider, IParseNodeFactory parseNodeFactory = null, ISerializationWriterFactory serializationWriterFactory = null, System.Net.Http.HttpClient httpClient = null) { authProvider = authenticationProvider ?? throw new ArgumentNullException(nameof(authenticationProvider)); createdClient = httpClient == null; client = httpClient ?? new System.Net.Http.HttpClient(); pNodeFactory = parseNodeFactory ?? ParseNodeFactoryRegistry.DefaultInstance; sWriterFactory = serializationWriterFactory ?? SerializationWriterFactoryRegistry.DefaultInstance; }
/// <summary> /// Initializes a new instance of the <see cref="ParserFactory"/> class. /// </summary> /// <param name="parseTableFormat">The parse table format.</param> /// <param name="parseNodeFactory">The parse node factory.</param> /// <param name="parseTreeBuilder">The parse tree builder.</param> public ParserFactory(IParseTableFormat parseTableFormat, IParseNodeFactory parseNodeFactory, IParseTreeTransformer<ITerm> parseTreeBuilder) { #region Contract Contract.Requires<ArgumentNullException>(parseTableFormat != null); Contract.Requires<ArgumentNullException>(parseNodeFactory != null); Contract.Requires<ArgumentNullException>(parseTreeBuilder != null); #endregion this.parseTableFormat = parseTableFormat; this.parseNodeFactory = parseNodeFactory; this.parseTreeBuilder = parseTreeBuilder; }
/// <summary> /// Enables the backing store on default parse nodes factories and the given parse node factory. /// </summary> /// <param name="original">The parse node factory to enable the backing store on.</param> /// <returns>A new parse node factory with the backing store enabled.</returns> public static IParseNodeFactory EnableBackingStoreForParseNodeFactory(IParseNodeFactory original) { IParseNodeFactory result = original ?? throw new ArgumentNullException(nameof(original)); if (original is ParseNodeFactoryRegistry registry) { EnableBackingStoreForParseNodeRegistry(registry); } else { result = new BackingStoreParseNodeFactory(original); } EnableBackingStoreForParseNodeRegistry(ParseNodeFactoryRegistry.DefaultInstance); return(result); }
/// <summary> /// Creates a new proxy factory that wraps the specified concrete factory while composing the before and after callbacks. /// </summary> /// <param name="concrete">The concrete factory to wrap.</param> /// <param name="onBefore">The callback to invoke before the deserialization of any model object.</param> /// <param name="onAfter">The callback to invoke after the deserialization of any model object.</param> public ParseNodeProxyFactory(IParseNodeFactory concrete, Action <IParsable> onBefore, Action <IParsable> onAfter) { _concrete = concrete ?? throw new ArgumentNullException(nameof(concrete)); _onBefore = onBefore; _onAfter = onAfter; }
/// <summary> /// Enables the backing store for the registered serialization and parse node factories /// </summary> public void EnableBackingStore() { pNodeFactory = ApiClientBuilder.EnableBackingStoreForParseNodeFactory(pNodeFactory) ?? throw new InvalidOperationException("Could not enable backing store for the parse node factory"); sWriterFactory = ApiClientBuilder.EnableBackingStoreForSerializationWriterFactory(sWriterFactory) ?? throw new InvalidOperationException("Could not enable backing store for the serializer writer factory"); }
/// <summary> /// Initializes a new instance of the <see cref="SglrEngine"/> class. /// </summary> /// <param name="reader">The text reader to read from.</param> /// <param name="parseTable">The parse table.</param> /// <param name="parseNodeFactory">The parse node factory.</param> public SglrEngine(TextReader reader, ParseTable parseTable, IParseNodeFactory parseNodeFactory) { #region Contract Contract.Requires<ArgumentNullException>(reader != null); Contract.Requires<ArgumentNullException>(parseTable != null); Contract.Requires<ArgumentNullException>(parseNodeFactory != null); #endregion this.reader = reader as PeekingReader ?? new PeekingReader(reader); this.parseTable = parseTable; this.parseNodeFactory = parseNodeFactory; // C0 = (s0 | a1 ... an) this.AcceptingStack = null; this.StartFrame = new Frame(this.parseTable.InitialState); this.activeStacks = new Deque<Frame>() { this.StartFrame }; }