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