public void Length_And_Count_Can_Be_Different_Empty_String_128() { var valueString = new ValueString <ValueString64, ValueString64>(); Assert.AreEqual(8, valueString.Length); Assert.AreEqual(0, valueString.Count); }
private bool ParseArea(Action <MapAreaName> setter, object value, string parsedFile, string parsedKey) { if (!(value is string ValueString)) { return(Program.ReportFailure($"Value {value} was expected to be a string")); } MapAreaName Area; if (ValueString == "*") { Area = MapAreaName.Any; StringToEnumConversion <MapAreaName> .SetCustomParsedEnum(Area); } else if (ValueString.StartsWith("Area")) { string AreaString = ValueString.Substring(4); if (!StringToEnumConversion <MapAreaName> .TryParse(AreaString, out Area)) { return(false); } } else { return(Program.ReportFailure($"Invalid area name {ValueString}")); } setter(Area); return(true); }
/// <summary> /// 开启视频预览 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void btnOk_Click(object sender, EventArgs e) { string terminalId = this.txtTerminalId.Text.Trim(); if (string.IsNullOrEmpty(terminalId)) { errPrv.SetError(this.txtTerminalId, "终端编号不能为空..."); this.txtTerminalId.Focus(); return; } ValueString <AVChannel> selChn = this.cboChn.SelectedItem as ValueString <AVChannel>; if (selChn == null) { errPrv.SetError(this.cboChn, "请选择有效的预览通道..."); this.cboChn.Focus(); return; } string svrIp = this.txtSvrIp.Text.Trim(); if (string.IsNullOrEmpty(svrIp)) { errPrv.SetError(this.txtSvrIp, "视频服务器IP地址不能为空..."); this.txtSvrIp.Focus(); return; } ushort svrPort = (ushort)this.nudPort.Value; this.btnOk.Enabled = false; this.TerminalId = null; var task = Task.Factory.StartNew(() => { var result = UrlApiHelper.ControlVideo(terminalId, selChn.Value, VedioControlType.RealTime); if (result == null) { GuiHelper.MsgBox("服务器连接异常..."); } else if (result.Status != 0) { GuiHelper.MsgBox("实时预览开启失败: " + result.Message); } else { this.TerminalId = terminalId; this.Channel = selChn.Value; Settings.Default.DVRSvrIp = svrIp; Settings.Default.DVRSvrPort = svrPort; } }); task.Wait(); this.btnOk.Enabled = true; if (!string.IsNullOrEmpty(this.TerminalId)) { this.DialogResult = DialogResult.OK; this.Close(); } }
public override void Do() { bool skill = ModificationByName("Skill", () => Character.Protagonist.Skills.Add(ValueString)); bool rmSkill = ModificationByName("RemoveSkill", () => Character.Protagonist.Skills.RemoveAll(item => item == ValueString)); bool rmTrigger = ModificationByName("RemoveTrigger", () => Game.Option.Trigger(ValueString, remove: true)); bool byTrigger = ModificationByName("ByTrigger", () => LifeByTrigger()); bool byNotTrigger = ModificationByName("ByNotTrigger", () => LifeByTrigger(notLogic: true)); bool byFood = ModificationByName("ByFood", () => LifeByFood()); if (skill || rmSkill || rmTrigger || byTrigger || byNotTrigger || byFood) { // nothing to do here } else if (Name == "ReplaceTrigger") { string[] triggers = ValueString.Split(new string[] { "->" }, StringSplitOptions.RemoveEmptyEntries); if (!Game.Data.Triggers.Contains(triggers[0].Trim())) { return; } Game.Option.Trigger(triggers[0].Trim(), remove: true); Game.Option.Trigger(triggers[1].Trim()); } else { InnerDo(Character.Protagonist); } }
public IEnumerable<Tuple<LanguageInfo, double>> Identify(ValueString text) { var extractor = new CharacterNGramExtractor(MaxNGramLength, OnlyReadFirstNLines); var tokens = extractor.GetFeatures(text); var likelyLanguages = _classifier.Classify(tokens); return likelyLanguages; }
private bool ParseDroppedAppearance(PgItem item, object value, string parsedFile, string parsedKey) { if (!(value is string ValueString)) { return(Program.ReportFailure(parsedFile, parsedKey, $"Value '{value}' was expected to be a string")); } string AppearanceString; int index = ValueString.IndexOf('('); if (index > 0) { if (index >= ValueString.Length - 2 || !ValueString.EndsWith(")")) { return(Program.ReportFailure(parsedFile, parsedKey, $"'{value}' is an invalid dropped appareance")); } AppearanceString = ValueString.Substring(0, index); string[] Details = ValueString.Substring(index + 1, ValueString.Length - index - 2).Split(';'); if (!ParseDroppedAppearanceDetails(item, Details, parsedFile, parsedKey)) { return(false); } } else { AppearanceString = ValueString; } return(StringToEnumConversion <ItemDroppedAppearance> .SetEnum((ItemDroppedAppearance valueEnum) => item.DroppedAppearance = valueEnum, AppearanceString)); }
public NumericalExpression(string expression, Dictionary <string, float> variables) { var valueString = new ValueString(expression, variables); values = valueString.values; elements = valueString.elements; }
public void ValueStringMethodsUseInvariantCultureByDefault() { var time = new DateTime(2016, 11, 28, 22, 59, 58); var fr = ValueString.Of(time.ToString(frCulture)); Assert.Equal("28/11/2016 22:59:58", fr.ToString()); Assert.Throws <InvalidCastException>(() => fr.As <DateTime>()); Assert.Equal(time, fr.As <DateTime>(frCulture)); Assert.False(fr.Is(out DateTime parsed)); Assert.True(fr.Is(frCulture, out parsed)); Assert.False(fr.Is(time)); Assert.True(fr.Is(time, frCulture)); Assert.Equal(time, parsed); var invariant = ValueString.Of(time); Assert.Equal("11/28/2016 22:59:58", invariant.ToString()); Assert.Throws <InvalidCastException>(() => invariant.As <DateTime>(frCulture)); Assert.Equal(time, invariant.As <DateTime>()); Assert.False(invariant.Is(frCulture, out parsed)); Assert.True(invariant.Is(out parsed)); Assert.False(invariant.Is(time, frCulture)); Assert.True(invariant.Is(time)); Assert.Equal(time, parsed); }
protected override void CreateObjects() { this.m_Value = new ValueString(); base.AddSubClass(this.Value); this.m_PropertyAdapter = new PlugInEditorControlPropertyAdapter(); this.Value.Changed += this.OnValueChanged; base.TextChanged += this.EditBox_TextChanged; }
public IEnumerable<Tuple<LanguageInfo, double>> Identify(ValueString text) { var extractor = new CharacterNGramExtractor(MaxNGramLength, OnlyReadFirstNLines); var tokens = extractor.GetFeatures(text); var model = LanguageModelCreator.CreateLangaugeModel(tokens, OccuranceNumberThreshold, MaximumSizeOfDistribution); var likelyLanguages = _classifier.Classify(model); return likelyLanguages; }
public void Length_And_Count_Can_Be_Different_128() { var valueString = new ValueString <ValueString64, ValueString64> { 'a', 'b', 'c', 'a', 'b', 'c' }; Assert.AreEqual(8, valueString.Length); Assert.AreEqual(6, valueString.Count); }
public void Length_And_Count_Should_Be_The_Same_Nested_192() { var valueString = new ValueString <ValueString <ValueString64, ValueString64>, ValueString64> { 'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b' }; Assert.AreEqual(12, valueString.Length); Assert.AreEqual(8, valueString.Count); }
public void ValueStringAllowsNullValues() { var vNull = ValueString.Of <object>(null); Assert.Null(vNull.ToString()); Assert.True(vNull.Equals(null as string)); Assert.True(vNull.Equals(null as object)); Assert.Throws <InvalidCastException>(() => vNull.As <double>()); Assert.Equal(default, vNull.As <double?>());
public void ValueListTest() { string expect = "#(1 2 3.1 \"4\")"; List <Value> x1 = ValueList.FromArguments(1, 2, 3.1, "4"); Value a1 = new Value(x1); Assert.AreEqual(expect, ValueString.ToString(x1)); Assert.AreEqual(expect, a1.ToString()); }
/// <summary> /// 获取末尾 /// </summary> /// <param name="count"></param> /// <returns></returns> public long GetTail(int count) { var val = long.Parse(ValueString.Substring(Length - count, count)); if (!IsPositive) { val = -val; } return(val); }
public int CompareTo(SCIMRepresentationAttribute other) { switch (SchemaAttribute.Type) { case SCIMSchemaAttributeTypes.BINARY: return(ValueBinary.CompareTo(other.ValueBinary)); case SCIMSchemaAttributeTypes.DATETIME: if (ValueDateTime == null) { return(-1); } if (other.ValueDateTime == null) { return(1); } return(ValueDateTime.Value.CompareTo(other.ValueDateTime.Value)); case SCIMSchemaAttributeTypes.DECIMAL: if (ValueDecimal == null) { return(-1); } if (other.ValueDecimal == null) { return(1); } return(ValueDecimal.Value.CompareTo(other.ValueDecimal.Value)); case SCIMSchemaAttributeTypes.INTEGER: if (ValueInteger == null) { return(-1); } if (other.ValueInteger == null) { return(1); } return(ValueInteger.Value.CompareTo(other.ValueInteger.Value)); case SCIMSchemaAttributeTypes.REFERENCE: return(ValueReference.CompareTo(other.ValueReference)); case SCIMSchemaAttributeTypes.STRING: return(ValueString.CompareTo(other.ValueString)); } return(0); }
public void HashCode_Should_Be_The_Same_For_Two_Objects_With_Same_Content_192() { var valueString1 = new ValueString <ValueString128, ValueString64> { 'a', 'b', 'a', 'b', 'c', 'b', 'c' }; var valueString2 = new ValueString <ValueString128, ValueString64> { 'a', 'b', 'a', 'b', 'c', 'b', 'c' }; Assert.AreEqual(valueString1.GetHashCode(), valueString2.GetHashCode()); }
public void HashCode_Should_Not_Be_The_Same_For_Two_Objects_With_Different_Content_128() { var valueString1 = new ValueString <ValueString64, ValueString64> { 'a', 'b', 'a', 'b', 'c' }; var valueString2 = new ValueString <ValueString64, ValueString64> { 'a', 'b', 'a', 'b', 'd' }; Assert.AreNotEqual(valueString1.GetHashCode(), valueString2.GetHashCode()); }
/// <summary> Set the current string.</summary> public virtual void SetCurrent(ValueString value) { //// current.Replace(current.ToString(0, current.Length - 0), value_Renamed, 0, current.Length - 0); current.Remove(0, current.Length); current.AppendValueString(value); cursor = 0; limit = current.Length; limit_backward = 0; bra = cursor; ket = limit; }
public void ValueStringConstructorUsesInvariantCulture() { CultureInfo.CurrentCulture = frCulture; var d = 1.5; Assert.Equal("1,5", d.ToString()); var v = ValueString.Of(d); // Converted using the invariant culture. Assert.Equal("1.5", v.ToString()); }
public void ToString_Should_Have_Same_Content_And_Length_As_Count_Partial_ValueString_128() { var referenceString = "aese2"; var valueString1 = new ValueString <ValueString64, ValueString64>(); foreach (var refChar in referenceString) { valueString1.Add(refChar); } var toString = valueString1.ToString(); Assert.AreEqual(referenceString, toString); Assert.AreEqual(valueString1.Count, toString.Length); }
public void DictionaryTest() { string expect = "#hash((a1 . 1) (a2 . 2) (\"b1\" . \"1\") (\"b2\" . 2.2))"; Symbol a1 = Symbol.Intern("a1"); Symbol a2 = Symbol.Intern("a2"); string b1 = "b1"; string b2 = "b2"; Dictionary <object, Value> table1 = ValueDictionary.FromArguments(a1, 1, a2, 2, b1, "1", b2, 2.2); Value t1 = new Value(table1); Assert.AreEqual(expect, ValueString.ToString(table1)); Assert.AreEqual(expect, t1.ToString()); }
public void BitwiseOrTest() { const string ValueString = "0123456789ABCDEFFEDCBA9876543210"; UInt128 value = UInt128.Parse(ValueString, NumberStyles.HexNumber, CultureInfo.InvariantCulture); Assert.AreEqual(UInt128.Parse(ValueString, NumberStyles.HexNumber, CultureInfo.InvariantCulture), value); for (int i = 0; i <= 32; ++i) { string orValueString = new string('0', i) + new string('F', ValueString.Length - i); UInt128 orValue = UInt128.Parse("0" + orValueString, NumberStyles.HexNumber, CultureInfo.InvariantCulture); string expectedValueString = ValueString.Substring(0, i) + new string('F', ValueString.Length - i); UInt128 expectedValue = UInt128.Parse(expectedValueString, NumberStyles.HexNumber, CultureInfo.InvariantCulture); UInt128 actualValue = value | orValue; Assert.AreEqual(expectedValue, actualValue, i.ToString()); } }
public void ShiftRightTest() { const string ValueString = "0123456789ABCDEFFEDCBA9876543210"; UInt128 value = UInt128.Parse(ValueString, NumberStyles.HexNumber, CultureInfo.InvariantCulture); Assert.AreEqual(UInt128.Parse(ValueString, NumberStyles.HexNumber, CultureInfo.InvariantCulture), value); for (int i = 0; i <= 124; i += 4) { string expectedValueString = new string('0', i / 4) + ValueString.Substring(0, ValueString.Length - i / 4); UInt128 expectedValue = UInt128.Parse(expectedValueString, NumberStyles.HexNumber, CultureInfo.InvariantCulture); Assert.AreEqual(expectedValue, value >> i, i.ToString()); Assert.AreEqual(expectedValue, value >> (i / 2) >> (i / 2), i.ToString()); Assert.AreEqual(expectedValue, value >> (i / 4) >> (i / 4) >> (i / 4) >> (i / 4), i.ToString()); } Assert.AreEqual <UInt128>(value >> 128, 0); }
public void Test() { var variables = new Dictionary <string, float> (); variables.Add("x", 3); variables.Add("y", -5); string code = "-x+7 * 2 - y *-(1+3*(7+x*2)) + 2"; var c = new ValueString(code, variables); var e = new NumericalExpression(c); float r = e.Evaluate(); print(r); //print(c.markedString); for (int i = 0; i < c.values.Count; i++) { //print(c.values[i]); } }
public bool Contains (TSelectionItem alias) { if (alias.NotNull ()) { // Tag if (string.IsNullOrEmpty (alias.ValueString)) { return (Tag.Equals (alias.Tag)); } // ValueString if (alias.Tag.IsNull ()) { return (ValueString.Equals (alias.ValueString, StringComparison.InvariantCulture)); } // both return (ValueString.Equals (alias.ValueString, StringComparison.InvariantCulture) && Tag.Equals (alias.Tag)); } return (false); }
private void LifeByTrigger(bool notLogic = false) { string[] values = ValueString.Split(new string[] { "->" }, StringSplitOptions.RemoveEmptyEntries); string[] triggers = values[0].Split('|'); bool isTrigger = false; foreach (string trigger in triggers) { if (Game.Data.Triggers.Contains(trigger.Trim()) || Character.Protagonist.Skills.Contains(trigger.Trim())) { isTrigger = true; } } if (isTrigger != notLogic) { Character.Protagonist.Life += int.Parse(values[1].Trim()); } }
public T GetGlobalParameterValue <T>(string parameterName, T defaultValue = default(T), string shopCode = "*") { T Result = defaultValue; //Search for shop param SY_GLOBAL_PARAMETER param = DBContext.SY_GLOBAL_PARAMETER.SingleOrDefault(E => E.PARAMETER_NAME == parameterName && E.DT_START <= DateTime.Today && E.DT_END >= DateTime.Today && E.SHOP_CODE == shopCode); if (param == null) //Search for global param { param = DBContext.SY_GLOBAL_PARAMETER.SingleOrDefault(E => E.PARAMETER_NAME == parameterName && E.DT_START <= DateTime.Today && E.DT_END >= DateTime.Today && E.SHOP_CODE == "*"); } if (param != null) { ValueString paramValue = ValueString.Of(param.PARAMETER_VALUE); Result = paramValue.As <T>(); } return(Result); }
public void ValueStringNullFailure() { var variations = new[] { new { value = (string)null, pass = false }, new { value = "", pass = false }, new { value = "test", pass = true }, }; foreach (var item in variations) { bool pass; ValueString t1 = null; try { t1 = new ValueString(item.value); pass = true; } catch { pass = false; } pass.Should().Be(item.pass, $"value={item.value}"); if (t1 != null) { t1.Should().NotBeNull(); t1.IsValueValid().Should().Be(item.pass); } } }
public override string ToString() { var sb = new StringBuilder(); sb.Append("("); var curent = First; while (curent != null) { sb.Append(ValueString.ToString(curent.Value)); curent = curent.Next; if (curent != null) { sb.Append(" "); } } sb.Append(")"); return(sb.ToString()); }
public static string FindValueString(ValueString[] strings, int value) { for (int i = 0; i < strings.Length; ++i) { if (strings[i].Value.Equals(value)) return (strings[i].Text); } return (null); }
/// <summary>A function was expecting a previous or next value</summary> internal Loki3Exception AddMissingValue(bool bPrevious) { m_map[keyMissingValue] = new ValueString(bPrevious ? "previous" : "next"); return this; }
private bool IsAllFromSameString(List<ValueString> strings, out ValueString all) { all = default(ValueString); int nextStart = -1; foreach (var item in strings) { if (!TryAddComponent(item, ref all, ref nextStart)) return false; } return true; }
public unsafe ValueString Concatenate(ValueString vs1, ValueString vs2) { if (object.ReferenceEquals(vs1._string, vs2._string) && vs1._start + vs1._length == vs2._start) { return new ValueString(vs1._string, vs1._start, vs1._length + vs2._length); } EnsureSpace(vs1.Length + vs2.Length); var m = used; CreateValueString(vs1); CreateValueString(vs2); return new ValueString(str, m, vs1._length + vs2._length); }
/// <summary>Could not parse token</summary> internal Loki3Exception AddBadToken(Token token) { m_map[keyBadToken] = new ValueString(token.Value); return this; }
/// <summary> /// 截断 /// </summary> /// <param name="startIndex"></param> /// <param name="count"></param> /// <returns></returns> public long GetSub(int startIndex, int count) { return(long.Parse(ValueString.Substring(startIndex, count))); }
/// <summary>Parameter that's the remainder of an array of a given type</summary> internal static Value Rest(string name, ValueType type) { ValueString vName = new ValueString(name); PatternData data = new PatternData(vName); data.Type = ValueClasses.ClassOf(type); data.UseRest = true; return vName; }
/// <summary>Tack on the file where the error occurred</summary> internal Loki3Exception AddFileName(string file) { m_map[keyFileName] = new ValueString(file); return this; }
/// <summary>Parameter that indicates that a "body" is required, i.e. an array of strings or parsed lines</summary> internal static Value Body() { ValueString vName = new ValueString("l3.body"); PatternData data = new PatternData(vName); // todo: data.ValueType = ValueType.RawList | ValueType.String; return vName; }
/// <summary>Parameter that's the remainder of an array or map</summary> internal static Value Rest(string name) { ValueString vName = new ValueString(name); PatternData data = new PatternData(vName); data.UseRest = true; return vName; }
/// <summary>Tack on the line where the error occurred</summary> internal Loki3Exception AddLine(string line) { m_map[keyLineContents] = new ValueString(line); return this; }
/// <summary> /// Translates dna sequence into triplet sequence. /// </summary> /// <param name="inputChain"> /// Nucleotide sequence. /// </param> /// <returns> /// Triplet sequence of <see cref="BaseChain"/> type. /// Elements are of <see cref="ValueString"/> type. /// </returns> public static BaseChain EncodeTriplets(BaseChain inputChain) { DnaProcessor.CheckDnaAlphabet(inputChain.Alphabet); var resultLength = (int)Math.Floor((double)inputChain.GetLength() / 3); var resultChain = new BaseChain(resultLength); for (int i = 0; i < resultLength * 3; i += 3) { resultChain[i / 3] = new ValueString(inputChain[i].ToString() + inputChain[i + 1] + inputChain[i + 2]); } return resultChain; }
/// <summary> /// Translates DNA sequence into amino acids. /// </summary> /// <param name="inputChain"> /// DNA sequence. /// </param> /// <returns> /// Amino acid sequence of type <see cref="BaseChain"/>. /// Elements are of <see cref="ValueString"/> type. /// </returns> public static BaseChain EncodeAmino(BaseChain inputChain) { DnaProcessor.CheckDnaAlphabet(inputChain.Alphabet); var count = (int)Math.Floor((double)inputChain.GetLength() / 3); var outChain = new BaseChain(count); for (int i = 0; i < count * 3; i += 3) { string first = inputChain[i].ToString(); string second = inputChain[i + 1].ToString(); string third = inputChain[i + 2].ToString(); switch (first) { case "T": switch (second) { case "T": if ((third == "T") || (third == "C")) { outChain[i / 3] = new ValueString('F'); } else { if ((third == "A") || (third == "G")) { outChain[i / 3] = new ValueString('L'); } else { throw new Exception(); } } break; case "C": outChain[i / 3] = new ValueString('S'); break; case "A": if ((third == "T") || (third == "C")) { outChain[i / 3] = new ValueString('Y'); } else { if ((third == "A") || (third == "G")) { outChain[i / 3] = new ValueString('X'); } else { throw new Exception(); } } break; case "G": if ((third == "T") || (third == "C")) { outChain[i / 3] = new ValueString('C'); } else { if (third == "A") { outChain[i / 3] = new ValueString('X'); } else { if (third == "G") { outChain[i / 3] = new ValueString('W'); } else { throw new Exception(); } } } break; default: throw new Exception(); } break; case "C": switch (second) { case "T": outChain[i / 3] = new ValueString('L'); break; case "C": outChain[i / 3] = new ValueString('P'); break; case "A": if ((third == "T") || (third == "C")) { outChain[i / 3] = new ValueString('H'); } else { if ((third == "A") || (third == "G")) { outChain[i / 3] = new ValueString('Q'); } else { throw new Exception(); } } break; case "G": outChain[i / 3] = new ValueString('R'); break; default: throw new Exception(); } break; case "A": switch (second) { case "T": if ((third == "T") || (third == "C") || (third == "A")) { outChain[i / 3] = new ValueString('I'); } else { if (third == "G") { outChain[i / 3] = new ValueString('M'); } else { throw new Exception(); } } break; case "C": outChain[i / 3] = new ValueString('T'); break; case "A": if ((third == "T") || (third == "C")) { outChain[i / 3] = new ValueString('N'); } else { if ((third == "A") || (third == "G")) { outChain[i / 3] = new ValueString('K'); } else { throw new Exception(); } } break; case "G": if ((third == "T") || (third == "C")) { outChain[i / 3] = new ValueString('S'); } else { if ((third == "A") || (third == "G")) { outChain[i / 3] = new ValueString('R'); } else { throw new Exception(); } } break; default: throw new Exception(); } break; case "G": switch (second) { case "T": outChain[i / 3] = new ValueString('V'); break; case "C": outChain[i / 3] = new ValueString('A'); break; case "A": if ((third == "T") || (third == "C")) { outChain[i / 3] = new ValueString('D'); } else { if ((third == "A") || (third == "G")) { outChain[i / 3] = new ValueString('E'); } else { throw new Exception(); } } break; case "G": outChain[i / 3] = new ValueString('G'); break; default: throw new Exception(); } break; default: throw new Exception(); } } return outChain; }
/// <summary>Tack on the function where the error occurred</summary> internal Loki3Exception AddFunction(string function) { m_map[keyFunction] = new ValueString(function); return this; }
/// <summary>Bad number of parameters passed to a function</summary> internal Loki3Exception AddBadCount(string explain) { m_map[keyBadCount] = new ValueString(explain); return this; }
private void Init(string end, DelimiterType type, ValueFunction function) { Map meta = WritableMetadata; meta[keyDelimEnd] = new ValueString(end); meta[keyDelimType] = new ValueInt((int)type); if (function != null) meta[keyDelimFunction] = function; }
/// <summary>Parameter that's a single named value with a default</summary> internal static Value Single(string name, Value theDefault) { ValueString vName = new ValueString(name); PatternData data = new PatternData(vName); data.Default = theDefault; return vName; }
/// <summary> /// Evaluates a token, possibly requesting the previous and next values. /// Returns a value. /// </summary> /// <param name="token">token representing a function or variable</param> /// <param name="scope">used to request functions, variables, and delimiters if there's no scope attached to the node</param> /// <param name="nodes">used to request previous and next nodes</param> internal static Value Do(DelimiterNode node, IScope scope, INodeRequestor nodes, ILineRequestor requestor) { if (node.Value != null) { // node has already been evaluated return node.Value; } else if (node.Token != null) { // function/variable or built-in Token token = node.Token; Value value = scope.GetValue(token); if (value is ValueFunction && nodes != null) { ValueFunction function = value as ValueFunction; // get previous & next nodes if needed DelimiterNode previous = (function.ConsumesPrevious ? nodes.GetPrevious() : null); DelimiterNode next = (function.ConsumesNext ? nodes.GetNext() : null); scope.FunctionName = token.Value; // evaluate try { return function.Eval(previous, next, scope, scope, nodes, requestor); } catch (Loki3Exception e) { // this function is the correct context if there isn't already one there if (!e.Errors.ContainsKey(Loki3Exception.keyFunction)) e.AddFunction(token.Value); if (!e.Errors.ContainsKey(Loki3Exception.keyScope)) e.AddScope(scope); throw e; } } else if (value != null) { return value; } else { return EvalBuiltin.Do(token); } } else if (node.List != null) { // delimited list of nodes Value value = null; DelimiterList list = node.List; IScope listScope = (list.Scope != null ? list.Scope : scope); DelimiterType type = list.Delimiter.DelimiterType; // get contents as a Value switch (type) { case DelimiterType.AsString: value = new ValueString(list.Original); break; case DelimiterType.AsValue: value = EvalList.Do(list.Nodes, listScope); break; case DelimiterType.AsArray: List<Value> values = new List<Value>(list.Nodes.Count); foreach (DelimiterNode subnode in list.Nodes) { // note: 'nodes' is null so functions don't get evaled Value subvalue = Do(subnode, listScope, null, requestor); values.Add(subvalue); } value = new ValueArray(values); break; case DelimiterType.AsEvaledArray: value = EvalList.DoEvaledArray(list.Nodes, listScope); break; case DelimiterType.AsRaw: value = new ValueRaw(list, listScope); break; case DelimiterType.AsArrayOfRaw: List<Value> rawvalues = new List<Value>(list.Nodes.Count); foreach (DelimiterNode subnode in list.Nodes) rawvalues.Add(new ValueRaw(subnode, listScope)); value = new ValueArray(rawvalues); break; } // run contents through a function if specified ValueFunction function = list.Delimiter.Function; if (function == null) return value; DelimiterNode next = new DelimiterNodeValue(value); return function.Eval(null, next, scope, scope, nodes, requestor); } return new ValueNil(); }
/// <summary>Parameter that's a single named value of the given type with a default</summary> internal static Value Single(string name, ValueType type, Value theDefault) { ValueString vName = new ValueString(name); PatternData data = new PatternData(vName); data.Type = ValueClasses.ClassOf(type); data.Default = theDefault; return vName; }
/// <summary> /// 获取末尾 /// </summary> /// <param name="tailCount"></param> /// <returns></returns> public long GetHeader(int tailCount) { return(long.Parse(ValueString.Substring(0, Length - tailCount))); }
/// <summary>Parameter that's a single named value that's one of a set of options</summary> internal static Value Single(string name, ValueArray oneOf) { ValueString vName = new ValueString(name); PatternData data = new PatternData(vName); data.OneOf = oneOf; return vName; }
/// <summary> /// Converts the string representation of a domain to it's 3 distinct components: /// Top Level Domain (TLD), Second Level Domain (SLD), and subdomain information /// </summary> /// <param name="domainString">The domain to parse</param> /// <param name="TLD"></param> /// <param name="SLD"></param> /// <param name="SubDomain"></param> /// <param name="MatchingRule"></param> internal static void ParseDomainName(string domainStringStr, out ValueString TLD, out ValueString SLD, out ValueString SubDomain, out TLDRule MatchingRule) { TLD = ValueString.Empty; SLD = ValueString.Empty; SubDomain = ValueString.Empty; MatchingRule = default(TLDRule); // If the fqdn is empty, we have a problem already if (string.IsNullOrWhiteSpace(domainStringStr)) throw new ArgumentException("The domain cannot be blank"); domainStringStr = domainStringStr.ToLowerFast(); var domainString = domainStringStr.AsValueString(); // Next, find the matching rule: MatchingRule = FindMatchingTLDRule(domainStringStr); // At this point, no rules match, we have a problem if (MatchingRule.Name == null) { var lastdot = domainString.LastIndexOf('.'); if (lastdot != -1 && char.IsDigit(domainString[lastdot + 1])) { // IP Address SLD = domainString; return; } else { if (lastdot == -1) { SLD = domainString; } else { TLD = domainString.Substring(lastdot + 1); var prev = domainString.LastIndexOf('.', lastdot - 1); if (prev != -1) { SubDomain = domainString.Substring(0, prev); SLD = domainString.Substring(prev + 1, lastdot - prev - 1); } else { SLD = domainString.Substring(0, lastdot); } } return; } } // Based on the tld rule found, get the domain (and possibly the subdomain) var tempSudomainAndDomain = ValueString.Empty; int tldIndex = 0; // First, determine what type of rule we have, and set the TLD accordingly switch (MatchingRule.Type) { case TLDRule.RuleType.Normal: if (domainString.Length == MatchingRule.Name.Length) { tempSudomainAndDomain = ValueString.Empty; TLD = domainString; } else { tldIndex = domainString.Length - MatchingRule.Name.Length - 1; tempSudomainAndDomain = domainString.Substring(0, tldIndex); TLD = domainString.Substring(tldIndex + 1); } break; case TLDRule.RuleType.Wildcard: // This finds the last portion of the TLD... tldIndex = domainString.Length - MatchingRule.Name.Length - 1; tempSudomainAndDomain = domainString.Substring(0, tldIndex); // But we need to find the wildcard portion of it: tldIndex = tempSudomainAndDomain.LastIndexOf('.'); tempSudomainAndDomain = domainString.Substring(0, tldIndex); TLD = domainString.Substring(tldIndex + 1); break; case TLDRule.RuleType.Exception: tldIndex = domainString.LastIndexOf('.'); tempSudomainAndDomain = domainString.Substring(0, tldIndex); TLD = domainString.Substring(tldIndex + 1); break; } // See if we have a subdomain: var lstRemainingParts = tempSudomainAndDomain.Split('.'); // If we have 0 parts left, there is just a tld and no domain or subdomain // If we have 1 part, it's the domain, and there is no subdomain // If we have 2+ parts, the last part is the domain, the other parts (combined) are the subdomain if (lstRemainingParts.Length > 0) { // Set the domain: SLD = lstRemainingParts[lstRemainingParts.Length - 1]; // Set the subdomain, if there is one to set: if (lstRemainingParts.Length > 1) { // We strip off the trailing period, too SubDomain = tempSudomainAndDomain.Substring(0, tempSudomainAndDomain.Length - SLD.Length - 1); } } }
/// <summary> /// Gets the metadata from a parameter name value /// </summary> /// <param name="name">object representing name of parameter</param> internal PatternData(ValueString name) { m_object = name; m_readableMetadata = (name == null ? null : name.Metadata); m_writableMetadata = null; }
private bool TryAddComponent(ValueString item, ref ValueString all, ref int nextStart) { if (item._length == 0) return true; if (all._string == null) { nextStart = item._start; all._start = item._start; all._string = item._string; } else { if (!object.ReferenceEquals(item._string, all._string)) return false; if (item._start != nextStart) return false; } all._length += item._length; nextStart += item._length; return true; }
public void TestNumber() { Value pattern = PatternData.Single("a", ValueType.Number); Value match = null, leftover = null; { // single int type - match Value input = new ValueInt(42); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(42, match.AsInt); Assert.AreEqual(null, leftover); } { // single float type - match Value input = new ValueFloat(3.5); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(3.5, match.AsFloat); Assert.AreEqual(null, leftover); } { // single string type - not a match Value input = new ValueString("hello"); Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); } }
public unsafe ValueString CreateValueString(ValueString vs) { fixed (char* dest = str) { var destx = dest + used; var offset = used; fixed (char* source = vs._string) { #if NET35 ValueString.CopyChars(source + vs._start, destx, vs._length); #else Buffer.MemoryCopy((void*)(source + vs._start), destx, vs._length * 2, vs._length * 2); #endif } return new ValueString(str, offset, vs._length); } }
/// <summary>Value wasn't of requested type</summary> internal Loki3Exception AddWrongType(ValueType expected, ValueType actual) { m_map[keyExpectedType] = new ValueString(ValueClasses.ClassOf(expected)); m_map[keyActualType] = new ValueString(ValueClasses.ClassOf(actual)); return this; }
/// <summary>Parameter that's a single named value</summary> internal static Value Single(string name) { ValueString vName = new ValueString(name); PatternData data = new PatternData(vName); return vName; }
/// <summary>Function overload is of a different "fix" type</summary> internal Loki3Exception AddWrongFix(string expected, string actual) { m_map[keyExpectedFix] = new ValueString(expected); m_map[keyActualFix] = new ValueString(actual); return this; }