public void TermTest_Nested_Sub_Conditions_StartOf_3_And_Kind_10()
{
// Arrange
_kind = new List <int>()
{
1, 10, 0
};
_getCall = new List <int>()
{
1, 4, 5, 0
};
_startOf = new List <int>()
{
1, 3, 0
};
_expr = new List <int>()
{
1, 4, 0
};
TermType expectedResult = TermType.Function;
// Act
InvokeParser_TermMethod();
// Assert
NUnit.Framework.Assert.AreEqual(expectedResult, _term.Type);
}
private Definition(string name, uint arity, TermType type)
{
Name = name;
Arity = arity;
Type = type == TermType.Function && arity == 0 ? TermType.Constant : type;
Order = type == TermType.Function ? FunctionIndex++ : VariableIndex++;
}
public override string ToString()
{
if (Terms == null)
{
string termString = String.Format("{0}{{{1}}}:{2}", TermType.ToString().ToUpperInvariant(), String.Join(",", Values), String.Join(",", Fields.Select(field => field.Name)));
if (Inverted.HasValue && Inverted.Value)
{
termString = "(NOT+" + termString + ")";
}
return(termString);
}
var sb = new StringBuilder();
sb.Append("(");
foreach (var term in Terms)
{
if (term.Operator.HasValue)
{
sb.Append("+" + term.Operator.ToString().ToUpperInvariant() + "+");
}
sb.Append(term);
}
sb.Append(")");
return(sb.ToString());
}
// TODO: Create in API an Object TermTypeLanguages
protected void Page_Load(object sender, System.EventArgs e)
{
lbMessage.Text = string.Empty;
#region Check Capabilities
//if ((SessionState.User.IsReadOnly) || (!SessionState.User.HasCapability(CapabilitiesEnum.MANAGE_TERM_BASE)))
//{
//uwToolbar.Items.FromKeyButton("Add").Enabled = false;
//uwToolbar.Items.FromKeyButton("Delete").Enabled = false;
//}
#endregion
//DDL_RegionList.AutoPostBack = false;
if (!Page.IsPostBack)
{
try
{
#region Load TermType list
using (TermTypeList TermTypes = TermType.GetAll())
{
DDL_TermTypeList.DataSource = TermTypes;
DDL_TermTypeList.DataBind();
}
#endregion
LoadRegionList();
ShowTermTypeLanguage();
}
catch
{
UITools.DenyAccess(DenyMode.Standard);
}
}
}
private void SomethingHeard(object sender,
SpeechRecognizedEventArgs e)
{
string txt = e.Result.Text;
float conf = e.Result.Confidence;
if (conf < RealTolerance)
{
return;
}
try
{
foreach (var lst in ListType)
{
if (lst.Item2.Equals(txt))
{
type = lst.Item1;
}
}
}
catch (DivideByZeroException ex)
{
logger.Error("Something went wrong", ex);
}
logger.Info("Listening... You said:" + "\"" + txt + "|" + type + "\"");
this.RaiseTermReceived(new VoiceTerm()
{
Type = type, Value = txt
});
}
private async Task PerformHangmanGame(TermType type)
{
using var hm = new Hangman(type);
if (HangmanGames.TryAdd(Context.Channel.Id, hm))
{
Task _client_MessageReceived(SocketMessage msg)
{
var _ = Task.Run(() => Context.Channel.Id == msg.Channel.Id ? hm.Input(msg.Author.Id, msg.Author.ToString(), msg.Content) : Task.CompletedTask);
return(Task.CompletedTask);
}
hm.OnGameEnded += Hm_OnGameEnded;
hm.OnGuessFailed += Hm_OnGuessFailed;
hm.OnGuessSucceeded += Hm_OnGuessSucceeded;
hm.OnLetterAlreadyUsed += Hm_OnLetterAlreadyUsed;
_client.MessageReceived += _client_MessageReceived;
try {
await Context.Channel.SendConfirmAsync($"{hm.ScrambledWordCode}\n{hm.GetHangman()}", $"{GetText("hangman_game_started")} ({hm.TermType})").ConfigureAwait(false);
} catch { }
await hm.EndedTask.ConfigureAwait(false);
_client.MessageReceived -= _client_MessageReceived;
HangmanGames.TryRemove(Context.Channel.Id, out var _);
}
else
{
await ReplyErrorLocalized("hangman_running").ConfigureAwait(false);
}
}
/// <summary>
/// Updates or creates a resource based on the resource identifier. The PUT operation is used to update or create a resource by identifier. If the resource doesn't exist, the resource will be created using that identifier. Additionally, natural key values cannot be changed using this operation, and will not be modified in the database. If the resource "id" is provided in the JSON body, it will be ignored as well.
/// </summary>
/// <param name="id">A resource identifier specifying the resource to be updated.</param>
/// <param name="IfMatch">The ETag header value used to prevent the PUT from updating a resource modified by another consumer.</param>
/// <param name="body">The JSON representation of the "termType" resource to be updated.</param>
/// <returns>A RestSharp <see cref="IRestResponse"/> instance containing the API response details.</returns>
public IRestResponse PutTermType(string id, string IfMatch, TermType body)
{
var request = new RestRequest("/termTypes/{id}", Method.PUT);
request.RequestFormat = DataFormat.Json;
request.AddUrlSegment("id", id);
// verify required params are set
if (id == null || body == null)
{
throw new ArgumentException("API method call is missing required parameters");
}
request.AddHeader("If-Match", IfMatch);
request.AddBody(body);
request.Parameters.First(param => param.Type == ParameterType.RequestBody).Name = "application/json";
var response = client.Execute(request);
var location = response.Headers.FirstOrDefault(x => x.Name == "Location");
if (location != null && !string.IsNullOrWhiteSpace(location.Value.ToString()))
{
body.id = location.Value.ToString().Split('/').Last();
}
return(response);
}
public SelectList GetSemanticListForDocument(int opusId, TermType typeOfList)
{
var lst = GetSemantics(opusId, typeOfList);
var sl = new SelectList(lst, "Key", "Value");
return(sl);
}
public TermStore(string name, TermType termType)
{
_name = name;
_termType = termType;
_multiValue = null;
_fieldValues = null;
}
private static void SetTermType() //todo IDE check, especially rider
{
_consoleColorSupportType = string.IsNullOrEmpty(Environment.GetEnvironmentVariable("WT_SESSION")) ?
string.IsNullOrEmpty(Environment.GetEnvironmentVariable("TERM")) ?
TermType.WIN_CMD : TermType.LINUX :
TermType.WIN_WT;
}
public static Term CreateTerm(TermType termType, bool systemTerm, bool IsManagedItem, Template template, bool isFilter)
{
switch (termType)
{
case TermType.Text:
return new TextTerm(systemTerm, template, isFilter);
case TermType.Date:
return new DateTerm(systemTerm, template, isFilter);
case TermType.Link:
return new LinkTerm(systemTerm, template, isFilter);
case TermType.MSO:
return new MSOTerm(systemTerm, template, isFilter);
case TermType.Renewal:
return new RenewalTerm(systemTerm, IsManagedItem, template, isFilter);
case TermType.Facility:
return new FacilityTerm(systemTerm, template, isFilter);
case TermType.PickList:
return new PickListTerm(systemTerm, template, isFilter);
case TermType.ComplexList:
return new ComplexList(systemTerm, template, false, isFilter);
case TermType.External:
throw new Exception("The CreateTerm method is not to be used when creating an external term.");
case TermType.PlaceHolderAttachments:
throw new Exception("The CreateTerm method is not to be used when creating a PlaceHolderAttachments term.");
case TermType.PlaceHolderComments:
throw new Exception("The CreateTerm method is not to be used when creating a PlaceHolderComments term.");
default:
throw new Exception(string.Format("Edit screen not implemented for TermType = {0}", termType));
}
}
private static bool IsInGrammar(string token, out TermType type, bool skipOperators = false)
{
bool result = false;
type = TermType.Operand;
switch (token.Trim())
{
case string s when IsDouble(token, out var _) && !token.StartsWith('+'):
type = TermType.Operand;
result = true;
break;
case string s when GrammarCatalog.BinaryOperators.ContainsKey(token) && !skipOperators:
type = TermType.Operator;
result = true;
break;
case string s when new string[] { "(", ")" }.Contains(s):
type = TermType.Parenthesis;
result = true;
break;
case string s when GrammarCatalog.Grammar.Any(t => t.StartsWith(s)):
type = TermType.Function;
result = true;
break;
}
return(result);
}
public StructureFunction(string name, int arity, TermType outputType, ConstructorInfo constructor, double priority, IList<TermType> inputTypes)
: base(name, arity, priority)
{
this.outputType = outputType;
this.inputTypes = inputTypes;
this.constructor = constructor;
}
public TreeNode(NodeType nodeType, TermType termType, List <IASTNode> nodes, string value = null)
{
NodeType = nodeType;
TermType = termType;
Nodes = nodes;
Value = value;
}
public LeafNode(TermType termType, string value)
{
NodeType = NodeType.Leaf;
TermType = termType;
Value = value;
Nodes = new List <IASTNode>();
}
public IEnumerable <KeyValuePair <int, string> > GetSemantics(int opusId, TermType type)
{
var prj = Ctx.Opuses.Find(opusId).Project;
var select = new Func <Term, KeyValuePair <int, string> >(t => new KeyValuePair <int, string>(t.Id, t.Text));
// if project is NOT SET for termset it applies for ALL projects
IEnumerable <KeyValuePair <int, string> > lst = null;
switch (type)
{
case TermType.Abbreviation:
lst = Ctx.AbbreviationTerms
.Include(t => t.TermSets)
.Include(t => t.TermSets.Select(ts => ts.Project))
.Where(t => t.Active && t.TermSets.Any(ts => ts.Project.Id == prj.Id))
.Select(select);
break;
case TermType.Cite:
lst = Ctx.CiteTerms
.Include(t => t.TermSets)
.Include(t => t.TermSets.Select(ts => ts.Project))
.Where(t => t.Active && t.TermSets.Any(ts => ts.Project.Id == prj.Id))
.Select(select);
break;
case TermType.Idiom:
lst = Ctx.IdiomTerms
.Include(t => t.TermSets)
.Include(t => t.TermSets.Select(ts => ts.Project))
.Where(t => t.Active && t.TermSets.Any(ts => ts.Project.Id == prj.Id))
.Select(select);
break;
case TermType.Variable:
lst = Ctx.VariableTerms
.Include(t => t.TermSets)
.Include(t => t.TermSets.Select(ts => ts.Project))
.Where(t => t.Active && t.TermSets.Any(ts => ts.Project.Id == prj.Id))
.Select(select);
break;
case TermType.Definition:
lst = Ctx.DefinitionTerms
.Include(t => t.TermSets)
.Include(t => t.TermSets.Select(ts => ts.Project))
.Where(t => t.Active && t.TermSets.Any(ts => ts.Project.Id == prj.Id))
.Select(select);
break;
case TermType.Link:
lst = Ctx.LinkTerms
.Include(t => t.TermSets)
.Include(t => t.TermSets.Select(ts => ts.Project))
.Where(t => t.Active && t.TermSets.Any(ts => ts.Project.Id == prj.Id))
.Select(select);
break;
}
return(lst);
}
public TreeNode(TermType termType, ActionType actionType, string value, List <TreeNode> childNodes, int uniqueKey)
{
TermType = termType;
ActionType = actionType;
Value = value;
ChildNodes = childNodes;
UniqueKey = uniqueKey;
}
public ActionResult DeleteConfirmed(int id)
{
TermType termType = db.TermTypes.Find(id);
db.TermTypes.Remove(termType);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Construct a constant term.
/// </summary>
/// <param name="value"></param>
public Term(double value)
: this()
{
this.type = TermType.Const;
this.info = new Info {
Value = value
};
}
/// <summary>
/// Create an N-ary operation on N terms.
/// </summary>
/// <param name="type"></param>
/// <param name="children"></param>
/// <returns></returns>
public static Term Nary(TermType type, params Term[] children)
{
if (children.Length != 2)
{
throw new ArgumentException("Only two children currently supported.");
}
return(children[0].Binary(type, children[1]));
}
/// <summary>
/// Construct a term variable.
/// </summary>
/// <param name="variable"></param>
internal Term(int variable)
: this()
{
this.type = TermType.Var;
this.info = new Info {
Variable = variable, VMask = 1 << variable
};
}
public void CopyValuesFrom(BaseTerm t)
{
functor = t.functor;
args = t.args;
termType = t.termType;
assocType = t.assocType;
precedence = t.precedence;
}
public Term(int id, TermType termType, int rowPosition, int columnPosition, string value, string numberString = null)
{
Id = id;
Type = termType;
RowPosition = rowPosition;
ColumnPosition = columnPosition;
NumberString = numberString;
Value = value;
}
/// <summary>
/// Use resources to resolve the enum names.
/// </summary>
/// <returns></returns>
public string GetLocalizedTermType()
{
return(typeof(TermType)
.GetField(TermType.ToString())
.GetCustomAttributes(typeof(DisplayAttribute), true)
.Cast <DisplayAttribute>()
.Single()
.GetName());
}
public List <Term> GetTerms(TermType type)
{
var request = _apiClient.CreateRequest("artist/list_terms");
request.AddQueryParameter("type", type.ToString().ToLowerInvariant());
var response = _apiClient.Execute <ArtistTermsResponse>(request);
return(response.Terms);
}
public object ConvertedValue(object source, TermType targetType)
{
if (targetType == this.OutputType)
{
return(source);
}
//TODO: convert
//return this.converts [targetType].Invoke (source, new object[0x00]);
return(source);
}
SimpleTermImpl(
CommonTree tree,
TermType type,
IDictionary <String, String> prefixMap
)
{
this.tree = tree;
this.type = type;
this.prefixMap = prefixMap;
}
public ActionResult Edit([Bind(Include = "Id,IsReadOnly,IsBlocked,Name")] TermType termType)
{
if (ModelState.IsValid)
{
db.Entry(termType).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(termType));
}
public Function(string name, int arity, TermType outputType = TermType.All, params TermType[] inputTypes)
: base(name, arity)
{
this.OutputType = outputType;
this.inputTypes = new TermType[arity];
for (int i = arity - 0x01; i >= 0x00; i--) {
this.inputTypes [i] = TermType.None;
}
this.WidenInput (inputTypes);
}
public List <Term> GetArtistTerms(string name, TermType type)
{
var request = _apiClient.CreateRequest("artist/terms");
request.AddQueryParameter("name", name);
request.AddQueryParameter("type", type.ToString());
var response = _apiClient.Execute <ArtistTermsResponse>(request);
return(response.Terms);
}
public Function(string name, int arity, TermType outputType = TermType.All, params TermType[] inputTypes) : base(name, arity)
{
this.OutputType = outputType;
this.inputTypes = new TermType[arity];
for (int i = arity - 0x01; i >= 0x00; i--)
{
this.inputTypes [i] = TermType.None;
}
this.WidenInput(inputTypes);
}
public FoundedTerm(SenteneType senteneType, TermType termType, string term, int amount, double exactHit, double similiarHit, double synonymHit)
{
this.SenteneType = senteneType;
this.Term = term;
this.TermType = termType;
this.Amount = amount;
this.ExactHit = exactHit;
this.SimiliarHit = similiarHit;
this.SynonymHit = synonymHit;
}
public static TokenType GetTokenType(this TermType source)
{
if (source == TermType.Number)
{
return(TokenType.Number);
}
else
{
return(TokenType.Variable);
}
}
public ActionResult Create([Bind(Include = "Id,IsReadOnly,IsBlocked,Name")] TermType termType)
{
if (ModelState.IsValid)
{
db.TermTypes.Add(termType);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(termType));
}
public override object ConvertedValue(TermType target)
{
switch (target) {
case TermType.Int:
return this.Value;
case TermType.Float:
return (double)this.value;
default :
throw new InvalidCastException ();
}
}
public TermParsedEventArgs( TermType tt,
string word,
string phrase,
long number,
string keyword,
Relation r,
bool exclude
)
{
this.termType = tt;
this.word = word;
this.phrase = phrase;
this.number = number;
this.keyword = keyword;
this.relation = r;
this.excludeTerm = exclude;
}
public Term(TermType typeofterm)
{
TypeOfTerm=typeofterm;
switch(typeofterm)
{
case TermType.ATOM: StrVal="";break;
case TermType.SMALL_ATOM: StrVal="";break;
case TermType.STRING: StrVal="";break;
case TermType.INTEGER: IntVal=0;break;
case TermType.SMALL_INTEGER: IntVal=0;break;
case TermType.LARGE_TUPLE: TupleVal=new List<Term>(); IntVal=0; break;
case TermType.LIST: TupleVal = new List<Term>(); IntVal = 0; break;
case TermType.SMALL_TUPLE: TupleVal=new List<Term>(); IntVal=0; break;
case TermType.NEW_FLOAT: FloatVal=0.0f;break;
//Default: do nothinc))
}
}
private static string pvariable(char[] fmt, ref int pos, out TermType type)
{
int start = pos;
for (pos = skip_null_chars(fmt, pos); pos < fmt.Length; pos++)
{
char c = fmt[pos];
if (char.IsLetterOrDigit(c) || (c == '_'))
continue;
else
break;
}
int i = pos;
int end = pos;
if (fmt.Length > i + 1 && fmt[i] == ':' && fmt[i + 1] == ':')
{
i = pos + 2;
int tps = i;
for (char c = fmt[i]; char.IsLetter(c) && i < fmt.Length - 1; c = fmt[++i]) ;
if (fmt[i] == '(' && i < fmt.Length - 1 && fmt[i + 1] == ')')
{
pos = i + 2;
string tp = new string(fmt, tps, i - tps);
switch (tp)
{
case "int":
case "integer":
type = TermType.Int;
break;
case "str":
case "string":
type = TermType.String;
break;
case "atom":
type = TermType.Atom;
break;
case "float":
case "double":
type = TermType.Double;
break;
case "binary":
type = TermType.Binary;
break;
case "bool":
case "boolean":
type = TermType.Boolean;
break;
case "byte":
type = TermType.Byte;
break;
case "char":
type = TermType.Char;
break;
case "list":
type = TermType.List;
break;
case "tuple":
type = TermType.Tuple;
break;
case "pid":
type = TermType.Pid;
break;
case "ref":
case "reference":
type = TermType.Ref;
break;
case "port":
type = TermType.Port;
break;
default:
throw new ArgumentException("Type '" + tps + "' is not supported!");
}
}
else
throw new ArgumentException("Invalid variable type specification: " +
new string(fmt, start, pos - start));
}
else
type = TermType.Object;
int len = end - start;
return new string(fmt, start, len);
}
private static string ConvertQuery(ParseTreeNode node, TermType type) {
string result = "";
// Note that some NonTerminals don't actually get into the AST tree,
// because of some Irony's optimizations - punctuation stripping and
// transient nodes elimination. For example, ParenthesizedExpression - parentheses
// symbols get stripped off as punctuation, and child expression node
// (parenthesized content) replaces the parent ParenthesizedExpression node
switch (node.Term.Name) {
case "BinaryExpression":
string opSym = string.Empty;
string op = node.ChildNodes[1].FindTokenAndGetText().ToLower();
string sqlOp = "";
switch(op) {
case "": case "&": case "and":
sqlOp = " AND ";
type = TermType.Inflectional;
break;
case "-":
sqlOp = " AND NOT ";
break;
case "|": case "or":
sqlOp = " OR ";
break;
}//switch
result = "(" + ConvertQuery(node.ChildNodes[0], type) + sqlOp + ConvertQuery(node.ChildNodes[2], type) + ")";
break;
case "PrimaryExpression":
result = "(" + ConvertQuery(node.ChildNodes[0], type) + ")";
break;
case "ProximityList":
string[] tmp = new string[node.ChildNodes.Count];
type = TermType.Exact;
for (int i = 0; i < node.ChildNodes.Count; i++) {
tmp[i] = ConvertQuery(node.ChildNodes[i], type);
}
result = "(" + string.Join(" NEAR ", tmp) + ")";
type = TermType.Inflectional;
break;
case "Phrase":
result = '"' + node.Token.ValueString + '"';
break;
case "ThesaurusExpression":
result = " FORMSOF (THESAURUS, " +
node.ChildNodes[1].Token.ValueString + ") ";
break;
case "ExactExpression":
result = " \"" + node.ChildNodes[1].Token.ValueString + "\" ";
break;
case "Term":
switch (type) {
case TermType.Inflectional:
result = node.Token.ValueString;
if (result.EndsWith("*"))
result = "\"" + result + "\"";
else
result = " FORMSOF (INFLECTIONAL, " + result + ") ";
break;
case TermType.Exact:
result = node.Token.ValueString;
break;
}
break;
// This should never happen, even if input string is garbage
default:
throw new ApplicationException("Converter failed: unexpected term: " +
node.Term.Name + ". Please investigate.");
}
return result;
}
protected Without (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
protected Funcall (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
public FunctionStructureAttribute(string name, TermType outputType)
: base(name)
{
this.outputType = outputType;
}
protected IndexRename (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
protected Bracket (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
protected Default (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
protected OuterJoin (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
protected ToJsonString (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
protected Contains (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
public static bool CanConvert(TermType frm, TermType to)
{
return (frm & to) == to;
}
protected Iso8601 (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
public override object ConvertedValue(TermType target)
{
return this.value;
}
protected DayOfYear (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
protected SetIntersection (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Term"/> class.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="type">The type.</param>
internal Term(object value, TermType type)
: this(value)
{
_termType = type;
}
protected September (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
public Poco(TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
protected Binary (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs){
}
public Poco(TermType termType, Arguments args) : base(termType, args)
{
}
protected Circle (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
protected March (TermType termType, Arguments args, OptArgs optargs) : base(termType, args, optargs)
{
}
