public ExecProcessor(FormatTemplate execTemplate, FormatTemplate argumentsTemplate, bool noWindow, bool wait) { this.exeTemplate = execTemplate; this.argsTemplate = argumentsTemplate; this.noWindow = noWindow; this.wait = wait; }
public CopyProcessor(FormatTemplate dstTemplate) { this.dstTemplate = dstTemplate; }
public RenameProcessor(FormatTemplate dstTemplate) { this.dstTemplate = dstTemplate; }
public static ISet <Grammar <TokenType, IProcessor> > GetGrammers() { // Filter processor. RepeatingSequenceRule <TokenType> rsr = new RepeatingSequenceRule <TokenType>(true, TokenType.LogicOperator) { new Rule <TokenType>(TokenType.ItemProperty, TokenType.GlobalProperty, TokenType.NumberValue, TokenType.StringValue, TokenType.TextValue) { TokenConverter = value => value }, new OptionalRule <TokenType>(TokenType.Unit) { TokenConverter = value => value }, new OptionalRule <TokenType>(TokenType.Ignore) { TokenConverter = value => value }, new OptionalRule <TokenType>(TokenType.Not) { TokenConverter = value => value }, new Rule <TokenType>(TokenType.Operator) { TokenConverter = value => value }, new Rule <TokenType>(TokenType.ItemProperty, TokenType.GlobalProperty, TokenType.NumberValue, TokenType.StringValue, TokenType.TextValue) { TokenConverter = value => value }, new OptionalRule <TokenType>(TokenType.Unit) { TokenConverter = value => value }, }; rsr.TokenConverter = value => value; return(new HashSet <Grammar <TokenType, IProcessor> > { new Grammar <TokenType, IProcessor>(TokenType.Function, "print") { Construct = x => new PrintProcessor() }, new Grammar <TokenType, IProcessor>(TokenType.Function, "index") { Construct = x => new IndexProcessor() }, new Grammar <TokenType, IProcessor>(TokenType.Function, "sort") { Construct = x => new SortProcessor(x.Get <string>(0), x.Get <bool>(1)), Rules = { new OptionalRule <TokenType>("filesize", TokenType.TextValue, TokenType.StringValue), new OptionalRule <TokenType>(TokenType.Constant, "asc", "asc|desc") { TokenConverter = token => token.Value.Equals("asc",StringComparison.InvariantCultureIgnoreCase) } } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "eval") { Construct = x => new EvalProcessor(x.Get <bool>(0), x.Get <bool>(1)), Rules = { new OptionalRule <TokenType>(TokenType.Constant, false, "join|seq") { TokenConverter = token => token.Value.Equals("join",StringComparison.InvariantCultureIgnoreCase) }, new OptionalRule <TokenType>(TokenType.Constant, false, "append|replace") { TokenConverter = token => token.Value.Equals("append",StringComparison.InvariantCultureIgnoreCase) }, } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "scan") { Construct = x => new ScanProcessor(x.Get <bool>(0), x.Get <SearchOption>(1)), Rules = { new Rule <TokenType>(TokenType.Constant, "files|dirs|directories") { TokenConverter = token => token.Value.Equals("files",StringComparison.InvariantCultureIgnoreCase) }, new OptionalRule <TokenType>(TokenType.Constant, SearchOption.AllDirectories, "top") { TokenConverter = token => token.Value.Equals("top",StringComparison.InvariantCultureIgnoreCase) ? SearchOption.TopDirectoryOnly : SearchOption.AllDirectories }, } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "glob") { Construct = x => new GlobProcessor(x.Get <string>(0)), Rules = { new Rule <TokenType>(TokenType.TextValue, TokenType.StringValue) } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "in") { Construct = x => new InProcessor(x.Get <string>(0)), Rules = { new Rule <TokenType>(TokenType.TextValue, TokenType.StringValue) } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "out") { Construct = x => new OutProcessor(x.Get <string>(0)), Rules = { new Rule <TokenType>(TokenType.TextValue, TokenType.StringValue) } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "transform") { Construct = x => new TransformProcessor(x.Get <FormatTemplate>(0)), Rules = { new Rule <TokenType>(TokenType.TextValue, TokenType.StringValue, TokenType.ItemProperty) { TokenConverter = TokenConverterFormatTemplate } } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "extract") { Construct = x => { if (x.Get <int>(1) == 0) // first branch { return new ExtractProcessor(x.Get <string>(0), x.Get <string>(5), x.Get <string>(3), x.Get <bool>(6)); } else // second branch { return new ExtractProcessor(x.Get <string>(0), x.Get <string>(3), "value", x.Get <bool>(4)); } }, Rules = { new Rule <TokenType>(TokenType.StringValue), new BranchingRule <TokenType>() { Branches = { //extract "regex" from @{name} as @{ep} [numeric] new List <Rule <TokenType> >() { new Rule <TokenType>(TokenType.Keyword, "from"), new Rule <TokenType>(TokenType.ItemProperty) { TokenConverter = TokenConverterPropertyName }, new Rule <TokenType>(TokenType.Keyword, "as"), new Rule <TokenType>(TokenType.ItemProperty) { TokenConverter = TokenConverterPropertyName }, new OptionalRule <TokenType>(TokenType.Constant,false, "numeric") { TokenConverter = token => token.Value.Equals("numeric",StringComparison.InvariantCultureIgnoreCase) } }, // extract "regex" as @{ep} [numeric] new List <Rule <TokenType> >() { new Rule <TokenType>(TokenType.Keyword, "as"), new Rule <TokenType>(TokenType.ItemProperty) { TokenConverter = TokenConverterPropertyName }, new OptionalRule <TokenType>(TokenType.Constant,false, "numeric") { TokenConverter = token => token.Value.Equals("numeric",StringComparison.InvariantCultureIgnoreCase) } } } } } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "move") { Construct = x => new MoveProcessor(x.Get <FormatTemplate>(0)), Rules = { new Rule <TokenType>(TokenType.TextValue, TokenType.StringValue, TokenType.ItemProperty, TokenType.GlobalProperty) { TokenConverter = TokenConverterFormatTemplate } } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "copy") { Construct = x => new CopyProcessor(x.Get <FormatTemplate>(0)), Rules = { new Rule <TokenType>(TokenType.TextValue, TokenType.StringValue, TokenType.ItemProperty, TokenType.GlobalProperty) { TokenConverter = TokenConverterFormatTemplate } } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "rename") { Construct = x => new RenameProcessor(x.Get <FormatTemplate>(0)), Rules = { new Rule <TokenType>(TokenType.TextValue, TokenType.StringValue, TokenType.ItemProperty, TokenType.GlobalProperty) { TokenConverter = TokenConverterFormatTemplate } } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "exec") { Construct = x => new ExecProcessor(x.Get <FormatTemplate>(0), x.Get <FormatTemplate>(1), x.Get <bool>(2), x.Get <bool>(3)), Rules = { new Rule <TokenType>(TokenType.TextValue, TokenType.StringValue) { TokenConverter = TokenConverterFormatTemplate }, new OptionalRule <TokenType>(FormatTemplate.Build("@{filepath}"), TokenType.TextValue, TokenType.StringValue) { TokenConverter = TokenConverterFormatTemplate }, new OptionalRule <TokenType>(TokenType.Constant, false, "window|nowindow|no-window") { TokenConverter = token => token.Value.Equals("nowindow", StringComparison.InvariantCultureIgnoreCase) || token.Value.Equals("no-window", StringComparison.InvariantCultureIgnoreCase) }, new OptionalRule <TokenType>(TokenType.Constant, false, "wait") { TokenConverter = token => token.Value.Equals("wait", StringComparison.InvariantCultureIgnoreCase) } } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "filter") { Construct = x => { Filter.FilterBuilder builder = Filter.Builder(); Token <TokenType> leftValueToken = null; string op = null; bool ignore = false; bool invert = false; bool requiresLogic = false; foreach (Token <TokenType> token in x) { switch (token.TokenType) { case TokenType.GlobalProperty: case TokenType.ItemProperty: case TokenType.NumberValue: case TokenType.StringValue: case TokenType.TextValue: if (requiresLogic) { throw new Exception(token.Location); } if (leftValueToken == null) { leftValueToken = token; } else { if (op == null) { throw new Exception(token.Location); } string leftValue = GetOperandValue(leftValueToken); string rightValue = GetOperandValue(token); Operand opLeft = GetOperand(leftValueToken); Operand opRight = GetOperand(token); Operator oper = GetOperator(op, ignore, invert); builder.Condition(opLeft, oper, opRight); op = null; leftValueToken = null; requiresLogic = true; invert = false; } break; case TokenType.Ignore: ignore = true; break; case TokenType.Not: invert = true; break; case TokenType.LogicOperator: if (token.Value == "&") { builder.And(); requiresLogic = false; } else if (token.Value == "|") { builder.Or(); requiresLogic = false; } break; case TokenType.Operator: op = token.Value; break; default: throw new Exception(token.Location); } } return new FilterProcessor(builder.Create()); }, Rules = { rsr } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "avg") { Construct = x => new AvgProcessor(x.Get <string>(0), x.Get <string>(1)), Rules = { new Rule <TokenType>(TokenType.ItemProperty) { TokenConverter = TokenConverterPropertyName }, new OptionalRule <TokenType>(null, TokenType.TextValue, TokenType.StringValue) } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "sum") { Construct = x => new SumProcessor(x.Get <string>(0), x.Get <string>(1)), Rules = { new Rule <TokenType>(TokenType.ItemProperty) { TokenConverter = TokenConverterPropertyName }, new OptionalRule <TokenType>(null, TokenType.TextValue, TokenType.StringValue) } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "min") { Construct = x => new MinProcessor(x.Get <string>(0), x.Get <string>(1)), Rules = { new Rule <TokenType>(TokenType.ItemProperty) { TokenConverter = TokenConverterPropertyName }, new OptionalRule <TokenType>(null, TokenType.TextValue, TokenType.StringValue) } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "max") { Construct = x => new MaxProcessor(x.Get <string>(0), x.Get <string>(1)), Rules = { new Rule <TokenType>(TokenType.ItemProperty) { TokenConverter = TokenConverterPropertyName }, new OptionalRule <TokenType>(null, TokenType.TextValue, TokenType.StringValue) } }, new Grammar <TokenType, IProcessor>(TokenType.Function, "mkdir") { Construct = x => new MkDirProcessor(x.Get <FormatTemplate>(0)), Rules = { new OptionalRule <TokenType>(FormatTemplate.Build("@{value}"), TokenType.TextValue, TokenType.StringValue) { TokenConverter = TokenConverterFormatTemplate }, } } }); }
public MkDirProcessor(FormatTemplate template) { this.template = template; }
public MoveProcessor(FormatTemplate dstTemplate) { this.dstTemplate = dstTemplate; }
public TransformProcessor(FormatTemplate template) { this.template = template ?? throw new ArgumentNullException(nameof(template)); }
//create template for wellsection private void CreateFormatTemplate() { string templateName = "TOCWSTemplate"; string collName = "TOCWSTemplates"; //WellSectionService FormatTemplateCollection root = WellSectionProject.FormatTemplateCollection; using (ITransaction trans = DataManager.NewTransaction()) { trans.Lock(root); collName = FormatTemplateCollection.GetUniqueFormatTemplateCollectionName(collName); FormatTemplateCollection subColl; subColl = root.CreateFormatTemplateCollection(collName); templateName = FormatTemplateCollection.GetUniqueFormatTemplateName(templateName); wsTemplate = subColl.CreateFormatTemplate(templateName); trans.Commit(); } }