public void Setup() { ccu = new CodeCompileUnit(); mocks = new MockRepository(); engine = Engine.GlobalEngine; engine.BinPath = @"C:\Program Files (x86)\MSBuild"; project = new Project(); buildEngine = mocks.DynamicMock<MockBuildEngine>(project); logger = new NullLogger(); parserService = mocks.DynamicMock<ISiteTreeGeneratorService>(); naming = mocks.DynamicMock<INamingService>(); sourceStorage = mocks.DynamicMock<IParsedSourceStorageService>(); source = mocks.DynamicMock<ISourceGenerator>(); typeResolver = mocks.DynamicMock<ITypeResolver>(); treeService = mocks.DynamicMock<ITreeCreationService>(); viewSourceMapper = mocks.DynamicMock<IViewSourceMapper>(); generator = mocks.DynamicMock<IGenerator>(); task = new GenerateMonoRailSiteTreeTask(logger, parserService, naming, source, sourceStorage, typeResolver, treeService, viewSourceMapper, generator); item = mocks.DynamicMock<ITaskItem>(); parsedSource = mocks.DynamicMock<IParser>(); }
public object ReadYaml(IParser parser, Type type) { var scalar = (YamlDotNet.Core.Events.Scalar)parser.Current; var bytes = Convert.FromBase64String(scalar.Value); parser.MoveNext(); return bytes; }
public void Download(Uri uri, object metaData, IParser parser) { uriParserPairs.Add(metaData, parser); var request = (HttpWebRequest)WebRequest.Create(uri); var state = new RequestState { Request = request, Metadata = metaData }; request.BeginGetResponse(GetData, state); }
/// <summary> /// Initializes a new instance of the <see cref="ReportBuilder"/> class. /// </summary> /// <param name="parser">The IParser to use.</param> /// <param name="rendererFactory">The renderer factory.</param> /// <param name="targetDirectory">The directory where the generated report should be saved.</param> /// <param name="assemblyFilter">The assembly filter.</param> public ReportBuilder(IParser parser, IRendererFactory rendererFactory, string targetDirectory, IAssemblyFilter assemblyFilter) { if (parser == null) { throw new ArgumentNullException("parser"); } if (rendererFactory == null) { throw new ArgumentNullException("rendererFactory"); } if (targetDirectory == null) { throw new ArgumentNullException("targetDirectory"); } if (assemblyFilter == null) { throw new ArgumentNullException("assemblyFilter"); } this.parser = parser; this.rendererFactory = rendererFactory; this.targetDirectory = targetDirectory; this.assemblyFilter = assemblyFilter; }
public RazorMailSender(MailAddress sender, Uri baseUri, SmtpClient client, IParser parser) { Sender = sender; BaseUri = baseUri; Client = client ?? new SmtpClient("127.0.0.1"); Parser = parser ?? new HtmlAgilityPackParser(baseUri); }
/// <summary> /// Initializes a new instance of the <see cref="ReportGenerator" /> class. /// </summary> /// <param name="parser">The IParser to use.</param> /// <param name="assemblyFilter">The assembly filter.</param> /// <param name="classFilter">The class filter.</param> /// <param name="renderers">The renderers.</param> internal ReportGenerator(IParser parser, IFilter assemblyFilter, IFilter classFilter, IEnumerable<IReportBuilder> renderers) { if (parser == null) { throw new ArgumentNullException("parser"); } if (assemblyFilter == null) { throw new ArgumentNullException("assemblyFilter"); } if (classFilter == null) { throw new ArgumentNullException("classFilter"); } if (renderers == null) { throw new ArgumentNullException("renderers"); } this.parser = parser; this.assemblyFilter = assemblyFilter; this.classFilter = classFilter; this.renderers = renderers; }
/// <summary> /// Initializes a new instance of the <see cref="ParserAnalyzer" /> with the specified weight. /// </summary> /// <param name="parser">The parser.</param> /// <param name="weight">The analyzer weight.</param> /// <exception cref="System.ArgumentNullException">parser</exception> public ParserAnalyzer(IParser parser, float weight) : base(weight) { if (parser == null) throw new ArgumentNullException("parser"); Parser = parser; }
public static void MyClassInitialize(TestContext testContext) { FileManager.CopyTestClasses(); var report = XDocument.Load(filePath); parser = new OpenCoverParser(report); }
public void Add(string path, IParser parser) { if (cache.ContainsKey(path)) throw new ArgumentException(String.Format("Source for {0} already cached!", path)); cache[path] = parser; }
/// <summary> /// Creates the Importer object /// </summary> /// <param name="Parser">Parser to be used for reading the stream</param> /// <param name="ConnectionString">Connection string of the Target DB</param> /// <param name="TargetTableName"> Table Name in the target DB to which the data to be pushed</param> /// <param name="BatchCount">Batch Size for Sql Pushing</param> public Importer(IParser Parser, string ConnectionString, string TargetTableName, int BatchCount) { _parser = Parser; _connectionString = ConnectionString; _targetTableName = TargetTableName; _batchCount = BatchCount; }
private static void MainLoop(ILexer lexer, IParser parser) { // top ::= definition | external | expression | ';' while (true) { Console.Write("ready> "); switch (lexer.CurrentToken) { case (int)Token.EOF: return; case ';': lexer.GetNextToken(); break; case (int)Token.DEF: parser.HandleDefinition(); break; case (int)Token.EXTERN: parser.HandleExtern(); break; default: parser.HandleTopLevelExpression(); break; } } }
public Calculator(ICollection<IExportFactory<IOperation, OperationMetadata>> operationFactories, IParser parser) { this.parser = parser; this.OperationsDictionary = operationFactories.ToDictionary( e => e.Metadata.Operation, e => e.CreateExport().Value); }
/// <summary> /// Parses the specified <see cref="ISentence"/> object using a given <paramref name="parser"/>. /// </summary> /// <param name="sentence">The sentence to be parsed.</param> /// <param name="parser">The parser.</param> /// <param name="numParses">The number parses. Usually 1.</param> /// <returns>An array with the parsed results.</returns> /// <exception cref="System.ArgumentNullException"> /// <paramref name="sentence"/> /// or /// <paramref name="parser"/> /// </exception> /// <exception cref="System.ArgumentOutOfRangeException">numParses</exception> /// <exception cref="System.InvalidOperationException">The sentence is not tokenized.</exception> public static Parse[] ParseLine(ISentence sentence, IParser parser, int numParses) { if (sentence == null) throw new ArgumentNullException("sentence"); if (parser == null) throw new ArgumentNullException("parser"); if (numParses < 0) throw new ArgumentOutOfRangeException("numParses"); if (sentence.Tokens == null || sentence.Tokens.Count == 0) throw new InvalidOperationException("The sentence is not tokenized."); var sb = new StringBuilder(sentence.Length); for (var i = 0; i < sentence.Tokens.Count; i++) { sb.Append(sentence.Tokens[i].Lexeme).Append(' '); } sb.Remove(sb.Length - 1, 1); var start = 0; var p = new Parse(sb.ToString(), new Span(0, sb.Length), AbstractBottomUpParser.INC_NODE, 0, 0); for (var i = 0; i < sentence.Tokens.Count; i++) { p.Insert( new Parse( sb.ToString(), new Span(start, start + sentence.Tokens[i].Lexeme.Length), AbstractBottomUpParser.TOK_NODE, 0, i)); start += sentence.Tokens[i].Lexeme.Length + 1; } return numParses == 1 ? new[] { parser.Parse(p) } : parser.Parse(p, numParses); }
/// <summary> /// Constructor. /// </summary> /// <param name="parser">Parser implementation</param> /// <param name="printResults">Action to be invoked after the processing has finished</param> public ConsumerUnit(IParser<string> parser, Action<IEnumerable<string>> printResults) { Parser = parser; PrintResults = printResults; Results = new List<string>(); }
public StartParsing(IFilePaths filePaths, ILogFileReaderList logfileReaderList, ILogStatisticsRepository logStatisticsRepository, IParser parser) { _filePaths = filePaths; _logfileReaderList = logfileReaderList; _logStatisticsRepository = logStatisticsRepository; _parser = parser; }
private IEnumerable<ParsingEvent> EnumerationOf(IParser parser) { while (parser.MoveNext()) { yield return parser.Current; } }
public ExecutionContext(IParser parser) { Parser = parser; CaseSensitive = false; Store = CaseSensitive ? new Dictionary<string, ContextValue>() : new Dictionary<string, ContextValue>(StringComparer.InvariantCultureIgnoreCase); Dependencies = CaseSensitive ? new Dictionary<string, HashSet<string>>() : new Dictionary<string, HashSet<string>>(StringComparer.InvariantCultureIgnoreCase); }
public FileReader(IParser parser, string path ) { this.parser = parser; //TODO make this more generic icdString = File.ReadAllText(path); parser.ParseIcdCatalog(icdString); }
public MainWindow() { InitializeComponent(); pathToGit = new FileInfo(@"C:\Program Files (x86)\Git\bin\git.exe"); try { DirectoryCatalog catalog = new DirectoryCatalog(new FileInfo(Assembly.GetAssembly(typeof (MainWindow)).Location).DirectoryName); CompositionContainer container = new CompositionContainer(catalog); container.ComposeParts(this); } catch (CompositionException) { sqlParser = null; } var vm = new MainWindowViewModel(Properties.Settings.Default.Databases); vm.SourceChangeset = (DvcsScriptRepositoryBase.RevisionIdentifierBase)Properties.Settings.Default.LastChangeset ?? Properties.Settings.Default.LastTag; if (vm.SourceChangeset != null) { vm.SelectedSourceType = RevisionIdentifierConverter.GetLabelFromType(vm.SourceChangeset.GetType()); } var riConverter = (RevisionIdentifierConverter)Resources["riConverter"]; riConverter.DataContext = vm; DataContext = vm; }
void DoTestEnums (IParser parser) { ICompilationUnit unit = parser.Parse (null, "a.cs", @"enum TestEnum { A, B, C }").CompilationUnit; Assert.AreEqual (1, unit.Types.Count); IType type = unit.Types[0]; Assert.AreEqual (ClassType.Enum, type.ClassType); Assert.AreEqual ("TestEnum", type.Name); Assert.AreEqual (3, type.FieldCount); foreach (IField f in type.Fields) { Assert.IsTrue (f.IsConst); Assert.IsTrue (f.IsSpecialName); Assert.IsTrue (f.IsPublic); if (f.Name == "A") { Assert.AreEqual (2, f.Location.Line); } else if (f.Name == "B") { Assert.AreEqual (3, f.Location.Line); } else if (f.Name == "C") { Assert.AreEqual (4, f.Location.Line); } else { Assert.Fail ("Unknown field: " + f.Name); } } }
public ParserUi(IParser parser,ICGunitHost host) { InitializeComponent(); m_parser = parser; m_Host = host; m_Host.evProjectStatus += new onProjectStatus(Owner_evProjectStatus); }
public ExpEvaluator(IParser _parser,IOperatorImp _ops) { //Use IParser to parse it _OpInst = _ops; _exp_parser = _parser; // TODO: Add constructor logic here }
/// <summary> /// Instantiates a build script object. /// </summary> /// <remarks> /// This constructor will attempt to parse the given SQL and determine whether it is valid /// and whether the script creates the object specified by the given identifier. If the /// script is invalid in anyway, the <see cref="ScriptError"/> property will reflect that. /// </remarks> /// <param name="scriptObject">The identifier of the database object to build.</param> /// <param name="scriptContent">The build script SQL content.</param> /// <param name="parser">The sql script parser for reading the SQL script content.</param> public ScriptFile(TypedDatabaseObject scriptObject, string scriptContent, IParser parser) { ScriptObject = scriptObject; Content = scriptContent; existingDependencies = new HashSet<TypedDatabaseObject>(); try { Sql = parser.ParseSqlScript(scriptContent); AssertMatchingContent(); } catch (SqlParseException ex) { ScriptError = new SqlParseError(ex.Message); Sql = null; } catch(EmptyTextException) { ScriptError = new EmptyTextError(); Sql = null; } catch(MultipleStatementException ex) { ScriptError = new MultipleStatementError(ex.Count, ex.Allotment); Sql = null; } catch(UnexpectedObjectTypeException ex) { ScriptError = new UnexpectedObjectTypeError(ex.TypeName); Sql = null; } }
public ExpEvaluator(IParser _parser) { //Use IParser to parse it _exp_parser = _parser; // TODO: Add constructor logic here }
public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer) { var nodeEvent = parser.Peek<NodeEvent>(); var nodeType = GetTypeFromEvent(nodeEvent, expectedType); try { foreach (var deserializer in deserializers) { object value; if (deserializer.Deserialize(parser, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value)) { return value; } } } catch (YamlException) { throw; } catch (Exception ex) { throw new YamlException(nodeEvent.Start, nodeEvent.End, "Exception during deserialization", ex); } throw new YamlException( nodeEvent.Start, nodeEvent.End, string.Format( "No node deserializer was able to deserialize the node into type {0}", expectedType.AssemblyQualifiedName ) ); }
public Database Create(FileInfo pathToGit, IParser sqlParser) { var connectionStr = ConnectionString; Func<SqlConnection> connection = () => new SqlConnection(connectionStr); var repo = new GitScriptRepository(ScriptsPath, ServerName, DatabaseName, pathToGit, sqlParser); return new Database(ServerName, DatabaseName, connection, repo); }
public void a_scanner_and_some_terminals() { scanner = new ScanStrings(Input) { SkipWhitespace = true }; __this__ = new LiteralString("this"); __is__ = new LiteralString("is"); __wally__ = new LiteralString("wally"); __dr_jones__ = new LiteralString("Dr. Jones!"); }
/// <summary> /// Constructor /// </summary> /// <param name="AccessModifier">Access modifier</param> /// <param name="ClassName">Class name</param> /// <param name="ParameterList">Parameter list</param> /// <param name="Body">Body of the constructor</param> /// <param name="Parser">Parser to use</param> public Constructor(AccessModifier AccessModifier, string ClassName, IParameter[] ParameterList, string Body, IParser Parser) : base(Parser) { this.AccessModifier = AccessModifier; this.ClassName = ClassName; this.Parameters = ParameterList.ToList(); this.Body = Body; }
public LanguageCompiler(Grammar grammar) { Grammar = grammar; grammar.Init(); ScannerControlData scannerData = new ScannerControlData(grammar); Scanner = new Scanner(scannerData); Parser = new Lalr.Parser(Grammar); }
public Dict(string name, HtmlVersion versions, int model, IParser parser, ICheckAttribs checkAttribs) { _name = name; _versions = versions; _model = model; _parser = parser; _checkAttribs = checkAttribs; }
public EMListElements(EMDocument doc, EMElementOrigin origin, EMElement parent, EMListType type) : base(doc, origin, parent) { parser = GetParserByType(type); }
public static IParser <T, DateTimeParseOptions> FormatProvider <T>(this IParser <T, DateTimeParseOptions> parser, IFormatProvider value) => parser.WithOptions(parser.Options.WithFormatProvider(value));
public static IParser <T, DateTimeParseOptions> Format <T>(this IParser <T, DateTimeParseOptions> parser, params string[] value) => parser.WithOptions(parser.Options.WithFormats(value.ToImmutableArray()));
public static IParser <T, NumberParseOptions> Styles <T>(this IParser <T, NumberParseOptions> parser, NumberStyles value) => parser.WithOptions(parser.Options.WithStyles(value));
public DataFileParser(IParser headerParser, IParser recordParser) { _headerParser = headerParser as IParser <DataMeta>; _recordParser = recordParser as IRecordParser <T>; }
public T Deserialize <T>(IParser parser) { return((T)Deserialize(parser, typeof(T))); }
public void Setup() { _parser = new StringExpressionParser(); }
public static IParser <TInput, TOutput> RightApply <TMiddle, TOutput>(IParser <TInput, TOutput> item, IParser <TInput, TMiddle> middle, Func <TOutput, TMiddle, TOutput, TOutput> produce, Func <IParseState <TInput>, TOutput>?getMissingRight = null, Quantifier quantifier = Quantifier.ZeroOrMore) => new RightApply <TInput, TMiddle, TOutput> .Parser(item, middle, args => produce(args.Left, args.Middle, args.Right), quantifier, getMissingRight);
private static ILookup <Option, string> ParseOptions(Queue <string> argsQueue, IParser parser, Dictionary <string, Option> longNameIndex, Dictionary <string, Option> shortNameIndex, bool ignoreInvalidOptions = false) { var diagnostics = new List <string>(); var values = new LinkedList <Tuple <Option, string> >(); var optionsQueue = new Queue <ParsedOption>(); while (argsQueue.Count + optionsQueue.Count > 0) { var parsedOption = optionsQueue.Count > 0 ? optionsQueue.Dequeue() : parser.Parse(argsQueue); var matchedOption = parsedOption.PrefixKind == PrefixKind.Long ? LookUp(parsedOption.Key, longNameIndex) : parsedOption.PrefixKind == PrefixKind.Short ? LookUp(parsedOption.Key, shortNameIndex) : parsedOption.PrefixKind == PrefixKind.Either ? LookUp(parsedOption.Key, longNameIndex, shortNameIndex) : parsedOption.PrefixKind == PrefixKind.None ? LookUp(parsedOption.Key, longNameIndex, shortNameIndex) : null; if (matchedOption == null && !ignoreInvalidOptions) { diagnostics.Add(Inv("Configuration flag '{0}' not found", parsedOption.Key)); } else if (matchedOption != null) { Add(values, matchedOption, parsedOption.Value); optionsQueue.EnqueueAll(SafeExpand(matchedOption, parsedOption, parser, diagnostics)); } } if (diagnostics.Any()) { Check(false, PrintDiagnostics(diagnostics)); } return(values.ToLookup(tuple => tuple.Item1, tuple => tuple.Item2)); }
private static IEnumerable <ParsedOption> SafeExpand(Option matchedOption, ParsedOption parsedOption, IParser parser, List <string> diagnostics) { try { return(matchedOption.Expand(parsedOption.Value)); } catch (Exception e) { diagnostics.Add(Inv("Could not expand option [[ {0} ]]. Error message: {1}", parser.RenderSingleOption(parsedOption), e.GetLogEventMessage())); return(ParsedOption.EmptyCollection); } }
/// <summary>Initializer for all the fields (and nothing more).</summary> private Config(IParser parser, IReadOnlyCollection <Option> allConfigurationOptions, ILookup <Option, string> configuredOptions) { Parser = parser; AllConfigurationOptions = allConfigurationOptions; ConfiguredOptionValues = configuredOptions; }
/// <summary> /// Takes a collection of supported <see cref="Option"/>s, a queue of strings, and a <see cref="Parser"/>; /// parses all strings from <paramref name="args"/>, ensures that each matches a supported option from /// <paramref name="confOptions"/>, produces a <see cref="Config"/> containing parsed option values, /// then calls <see cref="Validate"/> to ensure that provided options' constraints (e.g., /// <see cref="Option.IsRequired"/>, <see cref="Option.IsMultiValue"/>, <see cref="Option.TryConvertValue(string)"/>) /// are all met. /// </summary> /// <remarks> /// <b>Mutates <paramref name="args"/></b> (by virtue of calling <see cref="IParser.Parse(Queue{string})"/>). /// </remarks> public static Config ParseCommandLineArgs(IEnumerable <Option> confOptions, Queue <string> args, IParser parser = null, bool caseInsensitive = false, bool ignoreInvalidOptions = false) { Contract.RequiresNotNull(confOptions); Contract.RequiresNotNull(args); Contract.Requires(args.All(a => !string.IsNullOrWhiteSpace(a))); parser = parser ?? DefaultParser; var stringComparer = caseInsensitive ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal; // create 'indexes' for configured options for quick lookups Dictionary <string, Option> longNameIndex; Dictionary <string, Option> shortNameIndex; CreateIndexes(confOptions, stringComparer, out longNameIndex, out shortNameIndex); // parse options and populate 'matched options' dictionary var matchedOptions = ParseOptions(args, parser, longNameIndex, shortNameIndex, ignoreInvalidOptions); // create, validate, and return new configuration var ans = new Config(parser, new List <Option>(confOptions), matchedOptions); ans.Validate(); return(ans); }
public object ReadYaml(IParser parser, Type type) { var value = parser.Consume <Scalar>().Value; return(Type.GetType(value, throwOnError: true) !); // Will throw instead of returning null }
public ParserSelectManyImpl2(IParser <TChar, TSource> source, IParser <TChar, TCollection> collection, Func <TSource, TCollection, TResult> resultSelector) { this.source = source; this.collection = collection; this.resultSelector = resultSelector; }
public IEnumerable <IParseResult <IEnumerable <TResult> > > Parse(ICursor <TSource> source) { firstParser = null; bool first = true; var any = new AnyParser <TSource, TResult>(parsers); var except = new List <IParser <TSource, TResult> >(); // See the AllParser.Parse method for an explanation of the optimization that is provided by this stack var branches = new Stack <ICursor <TSource> >(); using (var root = source.Branch()) { branches.Push(root); var query = ParseResult.ReturnSuccessMany <TResult>(0) .SelectMany( parsers.Select( parser => (Func <Tuple <IParseResult <IEnumerable <TResult> >, bool>, IEnumerable <IParseResult <IEnumerable <TResult> > > >) (value => { if (first) { first = false; firstParser = parser; } var branch = branches.Peek(); // Item2 is only true when value.Item1 is the last element of its sequence. if (value.Item2) { branch.Move(value.Item1.Length); return(any.Parse(except, branch).Select(result => result.YieldMany())); } else { var remainder = branch.Remainder(value.Item1.Length); branches.Push(remainder); return(any.Parse(except, remainder) .Select(result => result.YieldMany()) .OnErrorOrDisposed(() => { /* Finally() cannot be used here. SelectMany generates each value as a Tuple, indicating whether it's * the last value in the sequence. To gather that info it uses a side-effect that causes it to look-ahead * in the enumerator, which would cause Finally to execute and dispose of the branch before it's used * by the child sequence. SelectMany only calls Dispose when the sequence is no longer in use. */ branches.Pop().Dispose(); })); } })), (firstResult, secondResult) => firstResult.Concat(secondResult)); // Use an iterator block to ensure that the local variables in this method aren't shared between enumerators. foreach (var result in query) { yield return(result); } } }
/// <summary> /// a right-associative parser where the parser attempts to parse a sequence of items and middles /// recursively: self := <item> (<middle> <self>)*. /// </summary> /// <typeparam name="TMiddle"></typeparam> /// <typeparam name="TOutput"></typeparam> /// <param name="item"></param> /// <param name="middle"></param> /// <param name="produce"></param> /// <param name="getMissingRight"></param> /// <param name="quantifier"></param> /// <returns></returns> public static IParser <TInput, TOutput> RightApply <TMiddle, TOutput>(IParser <TInput, TOutput> item, IParser <TInput, TMiddle> middle, Func <RightApply <TInput, TMiddle, TOutput> .Arguments, TOutput> produce, Func <IParseState <TInput>, TOutput>?getMissingRight = null, Quantifier quantifier = Quantifier.ZeroOrMore) => new RightApply <TInput, TMiddle, TOutput> .Parser(item, middle, produce, quantifier, getMissingRight);
public object Deserialize(IParser parser) { return(Deserialize(parser, typeof(object))); }
/// <summary> /// A left-associative parser where the left item is parsed unconditionally, and the result of the /// left parser is applied to the right parser. This new result is then treated as the 'left' value /// for the next iteration of the right parser. This can be used when many rules have a common prefix /// and you don't want to backtrack through the prefix on every attempt. /// </summary> /// <typeparam name="TOutput"></typeparam> /// <param name="left"></param> /// <param name="getRight"></param> /// <param name="quantifier"></param> /// <returns></returns> public static IParser <TInput, TOutput> LeftApply <TOutput>(IParser <TInput, TOutput> left, Func <IParser <TInput, TOutput>, IParser <TInput, TOutput> > getRight, Quantifier quantifier = Quantifier.ZeroOrMore) => new LeftApply <TInput, TOutput> .Parser(left, getRight, quantifier);
public Engine(IReader reader, IWriter writer, IParser parser) { this.reader = reader; this.writer = writer; this.parser = parser; }
public static IParser <T> Choose <T>(this IParser <T> parser, IEqualityComparer <T> comparer, params T[] choices) => from v in parser where choices.Contains(v, comparer) select v;
internal BinaryOperatorParser(IDictionary <char, BinaryOperatorFactory> supportedOperators, IParser next) { _supportedOperators = supportedOperators; _next = next; }
protected override async Task <IEnumerable <TSchema> > GetDataAsync <TSchema>(LocalStorageDataConfig config, int pageSize, IParser <TSchema> parser) { var uri = new Uri(string.Format("ms-appx://{0}", config.FilePath)); StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(uri); IRandomAccessStreamWithContentType randomStream = await file.OpenReadAsync(); using (StreamReader r = new StreamReader(randomStream.AsStreamForRead())) { return(await parser.ParseAsync(await r.ReadToEndAsync())); } }
public static IParser <T> Choose <T>(this IParser <T> parser, params T[] choices) => parser.Choose(EqualityComparer <T> .Default, choices);
/// <summary> /// Initializes a new instance of the <see cref="YamlScalarNode"/> class. /// </summary> internal YamlScalarNode(IParser parser, DocumentLoadingState state) { Load(parser, state); }
void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer) { Load(parser, new DocumentLoadingState()); }
public DebugTraceMessageClassifier(IParser <DebugTraceMessageData> parser) : base(parser) { }
public static IParser <T, DateTimeParseOptions> Styles <T>(this IParser <T, DateTimeParseOptions> parser, DateTimeStyles value) => parser.WithOptions(parser.Options.WithStyles(value));
public static ParserSelectManyImpl2 <TChar, TSource, TCollection, TResult> SelectMany <TChar, TSource, TCollection, TResult>(this IParser <TChar, TSource> source, IParser <TChar, TCollection> collection, Func <TSource, TCollection, TResult> resultSelector) { return(new ParserSelectManyImpl2 <TChar, TSource, TCollection, TResult>(source, collection, resultSelector)); }
public static IParser <T?> Nullable <T>(this IParser <T> parser) where T : struct => parser.Cast <T?>();
public OrdinalModel(IParser parser, IExtractor extractor) : base(parser, extractor) { }