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;
}
/// <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;
}
