/// <summary> /// Constructor /// </summary> /// <param name="reader">The XmlReader for current CSDL doc</param> /// <param name="getReferencedModelReaderFunc">The function to load referenced model xml. If null, will stop loading the referenced model.</param> private CsdlReader(XmlReader reader, Func <Uri, XmlReader> getReferencedModelReaderFunc) { this.reader = reader; this.getReferencedModelReaderFunc = getReferencedModelReaderFunc; this.errors = new List <EdmError>(); this.edmReferences = new List <IEdmReference>(); this.csdlParser = new CsdlParser(); // Setup the edmx parser. this.edmxParserLookup = new Dictionary <string, Action> { { CsdlConstants.Element_DataServices, this.ParseDataServicesElement }, { CsdlConstants.Element_Reference, this.ParseReferenceElement }, { CsdlConstants.Element_Runtime, this.ParseRuntimeElement } }; this.dataServicesParserLookup = new Dictionary <string, Action> { { CsdlConstants.Element_Schema, this.ParseSchemaElement } }; this.runtimeParserLookup = new Dictionary <string, Action> { { CsdlConstants.Element_ConceptualModels, this.ParseConceptualModelsElement } }; this.conceptualModelsParserLookup = new Dictionary <string, Action> { { CsdlConstants.Element_Schema, this.ParseSchemaElement } }; }
private EdmxReader(XmlReader reader) { this.reader = reader; this.errors = new List <EdmError>(); this.csdlParser = new CsdlParser(); // Setup the edmx parser. this.edmxParserLookup = new Dictionary <string, Action> { { CsdlConstants.Element_DataServices, this.ParseDataServicesElement }, { CsdlConstants.Element_Runtime, this.ParseRuntimeElement } }; this.dataServicesParserLookup = new Dictionary <string, Action> { { CsdlConstants.Element_Schema, this.ParseCsdlSchemaElement } }; this.runtimeParserLookup = new Dictionary <string, Action> { { CsdlConstants.Element_ConceptualModels, this.ParseConceptualModelsElement } }; this.conceptualModelsParserLookup = new Dictionary <string, Action> { { CsdlConstants.Element_Schema, this.ParseCsdlSchemaElement } }; }
public static ITextProcessor CreateTextProcessor(DelegateOutputProcessor <int> outputProcessor) { // Fist, define the calculator methods Func <int, int, Task <int> > sumFunc = (a, b) => Task.FromResult(a + b); // After that, the syntaxes for all operations, using the CSDL parser: // 1. Sum: // a) The default syntax, for inputs like 'sum 1 and 2' or 'sum 3 4' var sumSyntax = CsdlParser.Parse("operation+:VWord(sum) a:Integer :Word?(and) b:Integer"); // b) The alternative syntax, for inputs like '3 plus 4' var alternativeSumSyntax = CsdlParser.Parse("a:Integer :Word(plus,more) b:Integer"); // Now create the command processors, to bind the methods to the syntaxes var sumCommandProcessor = new DelegateCommandProcessor( sumFunc, true, outputProcessor, sumSyntax, alternativeSumSyntax ); // Finally, create the text processor and register all command processors var textProcessor = new TextProcessor(new PunctuationTextSplitter()); textProcessor.CommandProcessors.Add(sumCommandProcessor); textProcessor.TextPreprocessors.Add(new TrimTextPreprocessor()); return(textProcessor); }
public static ITextProcessor CreateTextProcessor() { // The parsed syntaxes var confirmOrderSyntax1 = CsdlParser.Parse( ":LDWord?(quero,mande,solicito) :Word?(uma) :Word?(pizza) :Word?(do,no) :LDWord?(tamanho) size:LDWord(pequena,media,média,grande,gigante) :Word?(sabor,de) flavor:LDWord(marguerita,pepperoni,calabreza) :Word?(para) :Word?(à,a,o) address:Text"); var confirmOrderSyntax2 = CsdlParser.Parse( ":LDWord?(quero,mande,solicito) :Word?(uma) :Word?(pizza) :Word?(sabor,de) flavor:LDWord(marguerita,pepperoni,calabreza) :Word?(do,no) :LDWord?(tamanho) size:LDWord(pequena,media,média,grande,gigante) :Word?(para) :Word?(à,a,o) address:Text"); var processOrderSyntax = CsdlParser.Parse( ":Word(sim) orderId:Long"); var cancelOrderSyntax = CsdlParser.Parse( ":Word(nao,não) orderId:Long"); // The output processor handles the command method return value var addReminderOutputProcessor = new DelegateOutputProcessor <string>( (text, context) => Console.WriteLine(text)); var pizza = new Pizza(); var confirmOrderCommandProcessor = new ReflectionCommandProcessor( pizza, nameof(ConfirmOrderAsync), true, addReminderOutputProcessor, confirmOrderSyntax1, confirmOrderSyntax2); var processOrderCommandProcessor2 = new ReflectionCommandProcessor( pizza, nameof(ProcessOrderAsync), true, addReminderOutputProcessor, processOrderSyntax); var cancelOrderCommandProcessor = new ReflectionCommandProcessor( pizza, nameof(CancelOrderAsync), true, addReminderOutputProcessor, cancelOrderSyntax); // Register the the processor var textProcessor = new TextProcessor(new PunctuationTextSplitter()); textProcessor.CommandProcessors.Add(confirmOrderCommandProcessor); textProcessor.CommandProcessors.Add(processOrderCommandProcessor2); textProcessor.CommandProcessors.Add(cancelOrderCommandProcessor); // Add some preprocessors to normalize the input text textProcessor.TextPreprocessors.Add(new TextNormalizerPreprocessor()); textProcessor.TextPreprocessors.Add(new ToLowerCasePreprocessor()); return(textProcessor); }
/// <summary> /// Returns an IEdmModel for the given CSDL artifacts. /// </summary> /// <param name="readers">Collection of XmlReaders containing the CSDL artifacts.</param> /// <param name="references">Models to be references by the created model.</param> /// <param name="model">The model generated by parsing.</param> /// <param name="errors">Errors reported while parsing.</param> /// <returns>Success of the parse operation.</returns> public static bool TryParse(IEnumerable <XmlReader> readers, IEnumerable <IEdmModel> references, out IEdmModel model, out IEnumerable <EdmError> errors) { CsdlModel ast; if (CsdlParser.TryParse(readers, out ast, out errors)) { model = new CsdlSemanticsModel(ast, new CsdlSemanticsDirectValueAnnotationsManager(), references); return(true); } model = null; return(false); }
public void AddProcessor(string syntaxPattern, Delegate fn = null) { var syntax = CsdlParser.Parse(syntaxPattern); fn = fn ?? (Func <Task <string> >)(() => Task.FromResult(string.Empty)); // Now create the command processors, to bind the methods to the syntaxes var cmd_proc = new DelegateCommandProcessor( fn, true, this, syntax ); CommandProcessors.Add(cmd_proc); }
public static ITextProcessor CreateTextProcessor() { // The parsed syntaxes var syntax1 = CsdlParser.Parse( ":Word(lembrar) :Word?(de) reminder:Text"); var syntax2 = CsdlParser.Parse( ":Word(lembre) :Word?(me) date:Word?(hoje,amanha,eventualmente) :Word?(de) reminder:Text"); var syntax3 = CsdlParser.Parse( ":Word?(me) :Word(lembre) :Word~(de) reminder:Text date:Word?(hoje,amanha,eventualmente) :Word?(a) time:Word?(manha,tarde,noite)"); // The output processor handles the command method return value var addReminderOutputProcessor = new DelegateOutputProcessor <string>( (text, context) => Console.WriteLine(text)); var calendar = new Calendar2(); var commandProcessor1 = new ReflectionCommandProcessor( calendar, nameof(AddReminderAsync), true, addReminderOutputProcessor, syntax1); var commandProcessor2 = new ReflectionCommandProcessor( calendar, nameof(AddReminderForDateAsync), true, addReminderOutputProcessor, syntax2); var commandProcessor3 = new ReflectionCommandProcessor( calendar, nameof(AddReminderForDateAndTimeAsync), true, addReminderOutputProcessor, syntax3); // Register the the processor var textProcessor = new TextProcessor(); textProcessor.CommandProcessors.Add(commandProcessor1); textProcessor.CommandProcessors.Add(commandProcessor2); textProcessor.CommandProcessors.Add(commandProcessor3); // Add some preprocessors to normalize the input text textProcessor.TextPreprocessors.Add(new TextNormalizerPreprocessor()); textProcessor.TextPreprocessors.Add(new ToLowerCasePreprocessor()); return(textProcessor); }
SlidingTextProcessor CreateTextProcessor <TRes>(string syntaxPattern, Delegate fn) { var out_proc = new DelegateOutputProcessor <TRes>( (o, ctx) => Log($"Result: {o}; op: {ctx.GetVariable("operation")}")); var syntax = CsdlParser.Parse(syntaxPattern); // Now create the command processors, to bind the methods to the syntaxes var cmd_proc = new DelegateCommandProcessor( fn, true, out_proc, syntax ); // Finally, create the text processor and register all command processors //var text_proc = new TextProcessor(new PunctuationTextSplitter()); var text_proc = new SlidingTextProcessor(); text_proc.CommandProcessors.Add(cmd_proc); text_proc.TextPreprocessors.Add(new TrimTextPreprocessor()); return(text_proc); }
private EdmxReader(XmlReader reader) { this.reader = reader; this.errors = new List <EdmError>(); this.csdlParser = new CsdlParser(); Dictionary <string, Action> strs = new Dictionary <string, Action>(); strs.Add("DataServices", new Action(this.ParseDataServicesElement)); strs.Add("Runtime", new Action(this.ParseRuntimeElement)); this.edmxParserLookup = strs; Dictionary <string, Action> strs1 = new Dictionary <string, Action>(); strs1.Add("Schema", new Action(this.ParseCsdlSchemaElement)); this.dataServicesParserLookup = strs1; Dictionary <string, Action> strs2 = new Dictionary <string, Action>(); strs2.Add("ConceptualModels", new Action(this.ParseConceptualModelsElement)); this.runtimeParserLookup = strs2; Dictionary <string, Action> strs3 = new Dictionary <string, Action>(); strs3.Add("Schema", new Action(this.ParseCsdlSchemaElement)); this.conceptualModelsParserLookup = strs3; }
/// <summary> /// Adds a new command syntax to the <see cref="TextcMessageReceiver"/> builder. /// </summary> /// <param name="culture">The syntax culture.</param> /// <param name="syntaxPattern">The CSDL statement. Please refer to <seealso cref="https://github.com/takenet/textc-csharp#csdl"/> about the notation.</param> /// <returns></returns> public SyntaxTextcMessageReceiverBuilder ForSyntax(CultureInfo culture, string syntaxPattern) => ForSyntax(CsdlParser.Parse(syntaxPattern, culture));
/// <summary> /// Adds a new command syntax to the <see cref="TextcMessageReceiver"/> builder. /// </summary> /// <param name="syntaxPattern">The CSDL statement. Please refer to <seealso cref="https://github.com/takenet/textc-csharp#csdl"/> about the notation.</param> /// <returns></returns> public SyntaxTextcMessageReceiverBuilder ForSyntax(string syntaxPattern) => ForSyntax(CsdlParser.Parse(syntaxPattern));
/// <summary> /// Adds multiple command syntaxes to the <see cref="TextcMessageReceiver"/> builder. /// The added syntaxes should be related and will be associated to a same command processor. /// </summary> /// <param name="culture">The syntaxes culture.</param> /// <param name="syntaxPatterns">The CSDL statements. Please refer to <seealso cref="https://github.com/takenet/textc-csharp#csdl"/> about the notation.</param> /// <returns></returns> public SyntaxTextcMessageReceiverBuilder ForSyntaxes(CultureInfo culture, params string[] syntaxPatterns) => new SyntaxTextcMessageReceiverBuilder(_commandProcessorFactories, syntaxPatterns.Select(s => CsdlParser.Parse(s, culture)).ToList(), this);
public static ITextProcessor CreateTextProcessor() { // 1. Define the calendar syntaxes, using some LDWords for input flexibility var addReminderSyntax = CsdlParser.Parse( "^[:Word?(hey,ok) :LDWord?(calendar,agenda) :Word?(add,new,create) command:LDWord(remind,reminder) :Word?(me) :Word~(to,of) message:Text :Word?(for) when:LDWord?(today,tomorrow,someday)]"); var partialAddReminderSyntax = CsdlParser.Parse( "^[:Word?(hey,ok) :LDWord?(calendar,agenda) :Word?(add,new,create) command+:LDWord(remind,reminder) :Word?(for,me) when+:LDWord?(today,tomorrow,someday)]"); var getRemindersSyntax = CsdlParser.Parse( "[when:LDWord?(today,tomorrow,someday) :LDWord(reminders)]"); // 2. Now the output processors var addReminderOutputProcessor = new DelegateOutputProcessor <Reminder>((reminder, context) => { Console.WriteLine($"Reminder '{reminder.Message}' added successfully for '{reminder.When}'"); }); var getRemindersOutputProcessor = new DelegateOutputProcessor <IEnumerable <Reminder> >((reminders, context) => { var remindersDictionary = reminders .GroupBy(r => r.When) .ToDictionary(r => r.Key, r => r.Select(reminder => reminder.Message)); foreach (var when in remindersDictionary.Keys) { Console.WriteLine($"Reminders for {when}:"); foreach (var reminderMessage in remindersDictionary[when]) { Console.WriteLine($"* {reminderMessage}"); } Console.WriteLine(); } }); // 3. Create a instance of the processor object to be shared by all processors var calendar = new Calendar(); // 4. Create the command processors var addRemiderCommandProcessor = new ReflectionCommandProcessor( calendar, nameof(AddReminderAsync), true, addReminderOutputProcessor, addReminderSyntax); var partialAddRemiderCommandProcessor = new DelegateCommandProcessor( new Func <string, Task>((when) => { Console.Write($"What do you want to be reminded {when}?"); return(Task.FromResult(0)); }), syntaxes: partialAddReminderSyntax); var getRemidersCommandProcessor = new ReflectionCommandProcessor( calendar, nameof(GetRemindersAsync), true, getRemindersOutputProcessor, getRemindersSyntax); // 5. Register the the processors var textProcessor = new TextProcessor(); textProcessor.CommandProcessors.Add(addRemiderCommandProcessor); textProcessor.CommandProcessors.Add(partialAddRemiderCommandProcessor); textProcessor.CommandProcessors.Add(getRemidersCommandProcessor); // 6. Add some preprocessors to normalize the input text textProcessor.TextPreprocessors.Add(new TextNormalizerPreprocessor()); textProcessor.TextPreprocessors.Add(new ToLowerCasePreprocessor()); return(textProcessor); }
public static ITextProcessor CreateTextProcessor() { // Fist, define the calculator methods Func <int, int, Task <int> > sumFunc = (a, b) => Task.FromResult(a + b); Func <int, int, Task <int> > subtractFunc = (a, b) => Task.FromResult(a - b); Func <int, int, Task <int> > multiplyFunc = (a, b) => Task.FromResult(a * b); Func <int, int, Task <int> > divideFunc = (a, b) => Task.FromResult(a / b); // After that, the syntaxes for all operations, using the CSDL parser: // 1. Sum: // a) The default syntax, for inputs like 'sum 1 and 2' or 'sum 3 4' var sumSyntax = CsdlParser.Parse("operation+:Word(sum) a:Integer :Word?(and) b:Integer"); // b) The alternative syntax, for inputs like '3 plus 4' var alternativeSumSyntax = CsdlParser.Parse("a:Integer :Word(plus,more) b:Integer"); // 2. Subtract: // a) The default syntax, for inputs like 'subtract 2 from 3' var subtractSyntax = CsdlParser.Parse("operation+:Word(subtract,sub) b:Integer :Word(from) a:Integer"); // b) The alternative syntax, for inputs like '5 minus 3' var alternativeSubtractSyntax = CsdlParser.Parse("a:Integer :Word(minus) b:Integer"); // 3. Multiply: // a) The default syntax, for inputs like 'multiply 3 and 3' or 'multiply 5 2' var multiplySyntax = CsdlParser.Parse("operation+:Word(multiply,mul) a:Integer :Word?(and,by) b:Integer"); // b) The alternative syntax, for inputs like '6 times 2' var alternativeMultiplySyntax = CsdlParser.Parse("a:Integer :Word(times) b:Integer"); // 4. Divide: // a) The default syntax, for inputs like 'divide 3 by 3' or 'divide 10 2' var divideSyntax = CsdlParser.Parse("operation+:Word(divide,div) a:Integer :Word?(by) b:Integer"); // b) The alternative syntax, for inputs like '6 by 2' var alternativeDivideSyntax = CsdlParser.Parse("a:Integer :Word(by) b:Integer"); // Define a output processor that prints the command results to the console var outputProcessor = new DelegateOutputProcessor <int>((o, context) => Console.WriteLine($"Result: {o}")); // Now create the command processors, to bind the methods to the syntaxes var sumCommandProcessor = new DelegateCommandProcessor( sumFunc, true, outputProcessor, sumSyntax, alternativeSumSyntax ); var subtractCommandProcessor = new DelegateCommandProcessor( subtractFunc, true, outputProcessor, subtractSyntax, alternativeSubtractSyntax ); var multiplyCommandProcessor = new DelegateCommandProcessor( multiplyFunc, true, outputProcessor, multiplySyntax, alternativeMultiplySyntax ); var divideCommandProcessor = new DelegateCommandProcessor( divideFunc, true, outputProcessor, divideSyntax, alternativeDivideSyntax ); // Finally, create the text processor and register all command processors var textProcessor = new TextProcessor(new PunctuationTextSplitter()); textProcessor.CommandProcessors.Add(sumCommandProcessor); textProcessor.CommandProcessors.Add(subtractCommandProcessor); textProcessor.CommandProcessors.Add(multiplyCommandProcessor); textProcessor.CommandProcessors.Add(divideCommandProcessor); textProcessor.TextPreprocessors.Add(new TrimTextPreprocessor()); return(textProcessor); }