void onValueChange(ValueInt v1, int v2) { if (_onValueChange != null) { _onValueChange(v1, v2); } }
public override IdpeMessage Parse(bool onlyConstraints) { try { if (base.Value.ToUpper() != "NULL") { this._ParseResult = new IdpeMessage(IdpeMessageCodes.IDPE_SUCCESS); if (ValueInt == null) { TryExtractingSpecificType(); if (ValueInt == null) //still null, then throw { this._ParseResult = new IdpeMessage(IdpeMessageCodes.IDPE_INT_TYPE_DATA_VALIDATION_FAILED); this._ParseResult.Message = string.Format(this._ParseResult.Message, PrintRowColPosition(), Type, base.Value); return(this._ParseResult); } } Value = ValueInt.ToString(); CheckConstraints(); } } catch (Exception ex) { ExtensionMethods.TraceError(ex.ToString()); this._ParseResult = new IdpeMessage(IdpeMessageCodes.IDPE_INT_TYPE_DATA_VALIDATION_FAILED); this._ParseResult.Message = string.Format(this._ParseResult.Message, PrintRowColPosition(), Type, base.Value); } _IsParsed = true; return(this._ParseResult); }
public static void Add(Arguments args, VM vm, SourceInfo info) { Check(args, 2, info); ValueInt integer1 = (ValueInt)args[0]; ValueInt integer2 = (ValueInt)args[1]; ValueInt newInteger = new ValueInt( integer1.Value + integer2.Value ); vm.Push(newInteger); }
private void readValueArray(BinaryReader br) { if (ValueLength == 0) { return; } Value[] Values = new Value[ArrayCount]; for (int i = 0; i < ArrayCount; i++) { switch (Type) { case ShaderParameterType.@int: Values[i] = new ValueInt(br); break; case ShaderParameterType.@float: Values[i] = new ValueFloat(br); break; case ShaderParameterType.float2: Values[i] = new ValueFloat2(br); break; case ShaderParameterType.float3: Values[i] = new ValueFloat3(br); break; case ShaderParameterType.float4: Values[i] = new ValueFloat4(br); break; case ShaderParameterType.@bool: Values[i] = new ValueBool(br); break; case ShaderParameterType.float4x3: Values[i] = new ValueFloat4x3(br); break; case ShaderParameterType.float4x4: Values[i] = new ValueFloat4x4(br); break; case ShaderParameterType.sampler: int len = ValueLength / ArrayCount; Values[i] = new ValueSamplerState(br, len); break; } } Value = new ValueList(Values); }
private void readValue(BinaryReader br) { if (ValueLength == 0) { return; } switch (Type) { case ShaderParameterType.@int: Value = new ValueInt(br); break; case ShaderParameterType.@float: Value = new ValueFloat(br); break; case ShaderParameterType.float2: Value = new ValueFloat2(br); break; case ShaderParameterType.float3: Value = new ValueFloat3(br); break; case ShaderParameterType.float4: Value = new ValueFloat4(br); break; case ShaderParameterType.@bool: Value = new ValueBool(br); break; case ShaderParameterType.float4x3: Value = new ValueFloat4x3(br); break; case ShaderParameterType.float4x4: Value = new ValueFloat4x4(br); break; case ShaderParameterType.sampler: Value = new ValueSamplerState(br, ValueLength); break; } }
public string GetDisplayableValue() { if (ValueInt != null) { return(ValueInt.ToString()); } if (ValueFloat != null) { return(ValueFloat.ToString()); } if (ValueCol != null) { return(ValueCol.ToString()); } return("#unimplemented value"); }
public bool IsValueDefault() { if (ValueInt != null) { return(ValueInt.Equals(ValueIntDefault)); } if (ValueFloat != null) { return(ValueFloat.Equals(ValueFloatDefault)); } if (ValueCol != null) { return(ValueCol.Equals(ValueColDefault)); } return(false); }
public int CompareTo(TestClass other) { if (ReferenceEquals(this, other)) { return(0); } if (ReferenceEquals(null, other)) { return(1); } var valueIntComparison = ValueInt.CompareTo(other.ValueInt); if (valueIntComparison != 0) { return(valueIntComparison); } return(ValueChar.CompareTo(other.ValueChar)); }
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 void TestMapFromArrayPattern() { List<Value> list = new List<Value>(); list.Add(PatternData.Single("a", ValueType.Int)); list.Add(PatternData.Single("b", new ValueInt(17))); ValueArray pattern = new ValueArray(list); Value match = null, leftover = null; { // get a & b Map map = new Map(); map["a"] = new ValueInt(42); map["b"] = new ValueInt(31); ValueMap input = new ValueMap(map); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsMap.Count); Assert.AreEqual(42, match.AsMap["a"].AsInt); Assert.AreEqual(31, match.AsMap["b"].AsInt); Assert.AreEqual(null, leftover); } { // fill in default for b Map map = new Map(); map["a"] = new ValueInt(42); ValueMap input = new ValueMap(map); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsMap.Count); Assert.AreEqual(42, match.AsMap["a"].AsInt); Assert.AreEqual(17, match.AsMap["b"].AsInt); Assert.AreEqual(null, leftover); } { // leftover Map map = new Map(); map["b"] = new ValueInt(31); ValueMap input = new ValueMap(map); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(1, match.AsMap.Count); Assert.AreEqual(31, match.AsMap["b"].AsInt); Assert.AreEqual(1, leftover.AsMap.Count); Assert.AreEqual("a", leftover.AsMap["a"].AsString); } { // get a & b, ignore c because bShortPat=true Map map = new Map(); map["a"] = new ValueInt(42); map["b"] = new ValueInt(31); map["c"] = new ValueInt(31); ValueMap input = new ValueMap(map); Assert.IsTrue(PatternChecker.Do(input, pattern, true/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsMap.Count); Assert.AreEqual(42, match.AsMap["a"].AsInt); Assert.AreEqual(31, match.AsMap["b"].AsInt); Assert.AreEqual(null, leftover); } { // missing key List<Value> list2 = new List<Value>(); list2.Add(PatternData.Single("a", ValueType.Int)); list2.Add(PatternData.Rest("other")); ValueArray pattern2 = new ValueArray(list2); Map map = new Map(); map["b"] = new ValueInt(31); map["c"] = new ValueInt(31); ValueMap input = new ValueMap(map); Assert.IsFalse(PatternChecker.Do(input, pattern2, true/*bShortPat*/, out match, out leftover)); // but if "a" is present, it matches map["a"] = new ValueInt(42); Assert.IsTrue(PatternChecker.Do(input, pattern2, true/*bShortPat*/, out match, out leftover)); } }
public void TestMapDefault() { Map map = new Map(); map["first"] = PatternData.Single("first", new ValueInt(156)); // default map["second"] = PatternData.Single("second"); ValueMap pattern = new ValueMap(map); Value match = null, leftover = null; { // input is missing key w/ default - full match map = new Map(); map["second"] = new ValueInt(3); ValueMap input = new ValueMap(map); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsMap.Count); Assert.AreEqual(156, match.AsMap["first"].AsInt); Assert.AreEqual(3, match.AsMap["second"].AsInt); Assert.AreEqual(null, leftover); } { // input is missing key w/out default - match w/ leftover map = new Map(); map["first"] = new ValueInt(5); ValueMap input = new ValueMap(map); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(1, match.AsMap.Count); Assert.AreEqual(5, match.AsMap["first"].AsInt); Assert.AreEqual(1, leftover.AsMap.Count); Assert.AreEqual("second", leftover.AsMap["second"].AsString); } }
public void TestMap() { Map map = new Map(); map["do?"] = PatternData.Single("do?", ValueType.Bool); map["body"] = PatternData.Body(); ValueMap pattern = new ValueMap(map); Value match = null, leftover = null; { // single object - not a match Value input = PatternData.Single("a"); Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); } { // input is a map w/ fewer keys - match w/ leftover map = new Map(); map["do?"] = new ValueBool(true); ValueMap input = new ValueMap(map); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(1, match.AsMap.Count); Assert.AreEqual(true, match.AsMap["do?"].AsBool); Assert.AreEqual(1, leftover.AsMap.Count); Assert.AreEqual("l3.body", leftover.AsMap["body"].AsString); } { // map w/ same keys - match map = new Map(); map["do?"] = new ValueBool(true); map["body"] = PatternData.Body(); ValueMap input = new ValueMap(map); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsMap.Count); Assert.AreEqual(true, match.AsMap["do?"].AsBool); Assert.AreEqual("l3.body", match.AsMap["body"].AsString); Assert.AreEqual(null, leftover); } { // map w/ extra keys - not a match map = new Map(); map["do?"] = new ValueBool(true); map["body"] = PatternData.Body(); map["something"] = new ValueInt(42); ValueMap input = new ValueMap(map); Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); } }
public void TestBool() { Value pattern = PatternData.Single("a", ValueType.Bool); Value match = null, leftover = null; { // single bool type - match Value input = new ValueBool(true); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.IsTrue(match.AsBool); Assert.AreEqual(null, leftover); } { // single int type - not a match Value input = new ValueInt(42); Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); } }
public void TestArray() { List<Value> list = new List<Value>(); list.Add(PatternData.Single("a", ValueType.Int)); list.Add(PatternData.Single("b", ValueType.String)); ValueArray pattern = new ValueArray(list); Value match = null, leftover = null; { // single object - not a match Value input = new ValueInt(37); Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); } { // array with one item - match with leftover List<Value> one = new List<Value>(); one.Add(new ValueInt(5)); ValueArray input = new ValueArray(one); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(1, match.AsArray.Count); Assert.AreEqual(5, match.AsArray[0].AsInt); Assert.AreEqual(1, leftover.AsArray.Count); Assert.AreEqual("b", leftover.AsArray[0].AsString); } { // array with two items of proper type - match List<Value> two = new List<Value>(); two.Add(new ValueInt(5)); two.Add(new ValueString("hello")); ValueArray input = new ValueArray(two); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsArray.Count); Assert.AreEqual(5, match.AsArray[0].AsInt); Assert.AreEqual("hello", match.AsArray[1].AsString); Assert.AreEqual(null, leftover); } { // array with two items of wrong type - not a match List<Value> two = new List<Value>(); two.Add(new ValueInt(5)); two.Add(new ValueFloat(2.718)); ValueArray input = new ValueArray(two); Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); } { // array with three items - not a match List<Value> three = new List<Value>(); three.Add(new ValueInt(5)); three.Add(new ValueString("hello")); three.Add(new ValueString("goodbye")); ValueArray input = new ValueArray(three); Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); } { // array with three items & smaller pattern is allowed List<Value> three = new List<Value>(); three.Add(new ValueInt(5)); three.Add(new ValueString("hello")); three.Add(new ValueString("goodbye")); ValueArray input = new ValueArray(three); Assert.IsTrue(PatternChecker.Do(input, pattern, true/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsArray.Count); Assert.AreEqual(5, match.AsArray[0].AsInt); Assert.AreEqual("hello", match.AsArray[1].AsString); Assert.AreEqual(null, leftover); } }
public void TestArrayOneOf() { // passed value must be a member of this list List<Value> options = new List<Value>(); options.Add(new ValueInt(5)); options.Add(new ValueInt(6)); ValueArray oneOf = new ValueArray(options); List<Value> list = new List<Value>(); list.Add(PatternData.Single("a", oneOf)); ValueArray pattern = new ValueArray(list); Value match = null, leftover = null; { // single object that's not a match Value input = new ValueInt(4); Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); } { // array with one item that matches one of the options List<Value> one = new List<Value>(); one.Add(new ValueInt(6)); ValueArray input = new ValueArray(one); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(1, match.AsArray.Count); Assert.AreEqual(6, match.AsArray[0].AsInt); Assert.AreEqual(null, leftover); } }
/// <summary>Tack on the line number where the error occurred</summary> internal Loki3Exception AddLineNumber(int line) { if (!m_map.ContainsKey(keyLineNumber)) m_map[keyLineNumber] = new ValueInt(line); return this; }
public void TestGetTypeFunction() { IScope scope = CreateValueScope(); { // built-in type w/out metadata scope.SetValue("a", new ValueInt(42)); Value value = TestSupport.ToValue("l3.getType { :value a }", scope); Assert.AreEqual("int", value.AsString); value = TestSupport.ToValue("l3.getType { :value a :builtin? true }", scope); Assert.AreEqual("int", value.AsString); value = TestSupport.ToValue("l3.getType { :key :a }", scope); Assert.AreEqual("int", value.AsString); } { // metadata type Value b = new ValueInt(42); b.MetaType = "myType"; scope.SetValue("b", b); Value value = TestSupport.ToValue("l3.getType { :value b }", scope); Assert.AreEqual("myType", value.AsString); value = TestSupport.ToValue("l3.getType { :value b :builtin? true }", scope); Assert.AreEqual("int", value.AsString); } }
public void TestGetValue() { IScope scope = CreateValueScope(); scope.SetValue("aString", new ValueString("testing")); Map map = new Map(); map["one"] = new ValueInt(1); map["two"] = new ValueInt(2); ValueMap vMap = new ValueMap(map); scope.SetValue("aMap", vMap); List<Value> array = new List<Value>(); array.Add(new ValueInt(2)); array.Add(new ValueInt(4)); scope.SetValue("anArray", new ValueArray(array)); { Value value = TestSupport.ToValue("l3.getValue { :object aString :key 2 }", scope); Assert.AreEqual("s", value.AsString); } { Value value = TestSupport.ToValue("l3.getValue { :object aMap :key :two }", scope); Assert.AreEqual(2, value.AsInt); } { Value value = TestSupport.ToValue("l3.getValue { :object anArray :key 1 }", scope); Assert.AreEqual(4, value.AsInt); } { // providing a default when the key isn't present Value value = TestSupport.ToValue("l3.getValue { :object aMap :key :notThere :default 42 }", scope); Assert.AreEqual(42, value.AsInt); // default ignored if key is present value = TestSupport.ToValue("l3.getValue { :object aMap :key :one :default 42 }", scope); Assert.AreEqual(1, value.AsInt); } // asking for a key that doesn't exist returns nil... { Value value = TestSupport.ToValue("l3.getValue { :object aMap :key :notThere }", scope); Assert.IsTrue(value.IsNil); } // ...unless the collection has a default { vMap.WritableMetadata[PatternData.keyDefault] = new ValueInt(42); Value value = TestSupport.ToValue("l3.getValue { :object aMap :key :notThere }", scope); Assert.AreEqual(42, value.AsInt); } }
public override string ToPromela() { return(Attribute.ToPromela() + " = " + (Value == null ? ValueInt.ToString() : Value.ToPromela()) + ";"); }
public void TestRestOfMap() { Map map = new Map(); map["a"] = PatternData.Single("a", ValueType.Int); map["other"] = PatternData.Rest("other"); ValueMap pattern = new ValueMap(map); Value match = null, leftover = null; { // input is a map w/ fewer keys - match w/ leftover map = new Map(); map["a"] = new ValueInt(14); ValueMap input = new ValueMap(map); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsMap.Count); Assert.AreEqual(14, match.AsMap["a"].AsInt); Map rest = match.AsMap["other"].AsMap; Assert.AreEqual(0, rest.Count); // 'rest' is present but empty Assert.AreEqual(null, leftover); } { // input contains extra keys that will get stuffed in 'other' map = new Map(); map["a"] = new ValueInt(14); map["b"] = new ValueInt(3); map["c"] = new ValueInt(15); ValueMap input = new ValueMap(map); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsMap.Count); Assert.AreEqual(14, match.AsMap["a"].AsInt); Map rest = match.AsMap["other"].AsMap; Assert.AreEqual(2, rest.Count); Assert.AreEqual(3, rest["b"].AsInt); Assert.AreEqual(15, rest["c"].AsInt); Assert.AreEqual(null, leftover); } }
public static bool TryCreateValue(string typeString, string valueString, out Value value) { value = null; var isNull = valueString.Equals("NULL") || valueString.Equals("null") || valueString.Equals(""); switch (typeString) { case "integer": if (isNull) { value = new ValueInt(null); return(true); } if (!long.TryParse(valueString, out var intResult)) { return(false); } value = new ValueInt(intResult); return(true); case "string": if (isNull) { value = new ValueString(null); return(true); } value = new ValueString(valueString.Trim('\"')); return(true); case "time": if (isNull) { value = new ValueTime(null as RefStruct <long>); return(true); } value = new ValueTime(valueString); return(true); case "double": if (isNull) { value = new ValueDouble(null); return(true); } if (!double.TryParse(valueString, NumberStyles.Any, CultureInfo.InvariantCulture, out var doubleResult)) { return(false); } value = new ValueDouble(doubleResult); return(true); case "boolean": if (isNull) { value = new ValueBoolean(null); return(true); } if (!bool.TryParse(valueString, out var booleanResult)) { return(false); } value = new ValueBoolean(booleanResult); return(true); case "duration": if (isNull) { value = new ValueDuration(null as RefStruct <long>); return(true); } value = new ValueDuration(valueString); return(true); case "contact": if (isNull) { value = new ValueContact(null, null); return(true); } var split = valueString.Split(' '); if (split.Length != 2 && split.Length != 3) { return(false); } if (!IPAddress.TryParse(split[1], out var address)) { return(false); } var port = 555; if (split.Length == 3 && !int.TryParse(split[2], out port)) { return(false); } if (!split[0].StartsWith("/")) { split[0] = '/' + split[0]; } value = new ValueContact(new PathName(split[0]), address, port); return(true); } var splitByOf = typeString.Split(" of ", 2); if (splitByOf.Length != 2) { return(false); } var splitBySpace = splitByOf[1].Split(' ', 2); if (splitBySpace.Length != 2) { return(false); } if (!int.TryParse(splitBySpace[0], out var count)) { return(false); } // based on StackOverflow answer: https://stackoverflow.com/a/3147901 var collectionStrings = Regex.Split(valueString.Trim('{', '}', '[', ']'), ",(?=(?:[^']*'[^']*')*[^']*$)") .Select(s => s.Trim(' ')).ToList(); if (collectionStrings.Count != count) { if (count != 0 && (collectionStrings.Count != 1 || !string.IsNullOrEmpty(collectionStrings[0]))) { return(false); } collectionStrings = new List <string>(count); } var elements = new List <Value>(count); var elementTypeString = splitBySpace[1]; foreach (var element in collectionStrings) { if (!TryCreateValue(elementTypeString, element, out var elementVal)) { return(false); } elements.Add(elementVal); } if (!TryGetPrimitiveAttributeType(elementTypeString, out var elementType)) { return(false); } switch (splitByOf[0]) { case "set": value = new ValueSet(elements.ToHashSet(), elementType); return(true); case "list": value = new ValueList(elements, elementType); return(true); } return(false); }
public void TestSetValue() { IScope scope = CreateValueScope(); { Value value = TestSupport.ToValue("l3.setValue { :key :a :value 5 }", scope); Assert.AreEqual(5, value.AsInt); Value fetch = scope.GetValue(new Token("a")); Assert.AreEqual(5, fetch.AsInt); } { // change a Value value = TestSupport.ToValue("l3.setValue { :key :a :value 7.5 }", scope); Assert.AreEqual(7.5, value.AsFloat); Value fetch = scope.GetValue(new Token("a")); Assert.AreEqual(7.5, fetch.AsFloat); } { // set an array Value value = TestSupport.ToValue("l3.setValue { :key :key :value [ a 2 false ] }", scope); List<Value> array = value.AsArray; Assert.AreEqual(3, array.Count); Assert.AreEqual(7.5, array[0].AsFloat); Assert.AreEqual(2, array[1].AsInt); Assert.AreEqual(false, array[2].AsBool); Value fetch = scope.GetValue(new Token("key")); List<Value> fetchArray = fetch.AsArray; Assert.AreEqual(3, fetchArray.Count); Assert.AreEqual(7.5, fetchArray[0].AsFloat); Assert.AreEqual(2, fetchArray[1].AsInt); Assert.AreEqual(false, fetchArray[2].AsBool); } // create a nested scope IScope nested = new ScopeChain(scope); { // explicitly say create-if-needed TestSupport.ToValue("l3.setValue { :key :created :value 3 :create? true }", nested); Value fetch = nested.GetValue(new Token("created")); Assert.AreEqual(3, fetch.AsInt); } { // asking to reuse non-existent var throws bool bThrew = false; try { Value value = TestSupport.ToValue("l3.setValue { :key :doesnt-exist :value 3 :create? false }", nested); } catch (Loki3Exception e) { bThrew = true; Assert.AreEqual("doesnt-exist", e.Errors[Loki3Exception.keyBadToken].AsString); } Assert.IsTrue(bThrew); } { // set var on parent scope & reuse on nested scope TestSupport.ToValue("l3.setValue { :key :on-parent :value 5 :create? true }", scope); Assert.AreEqual(5, scope.AsMap["on-parent"].AsInt); TestSupport.ToValue("l3.setValue { :key :on-parent :value 4 :create? false }", nested); Assert.AreEqual(4, scope.AsMap["on-parent"].AsInt); Assert.AreNotEqual(null, nested.Exists("on-parent")); Assert.IsFalse(nested.AsMap.ContainsKey("on-parent")); } { // set a value on a map Map map = new Map(); map["one"] = new ValueInt(1); map["two"] = new ValueInt(2); ValueMap valueMap = new ValueMap(map); scope.SetValue("mymap", valueMap); Value value = TestSupport.ToValue("l3.setValue { :key :one :value 3 :map mymap }", scope); Assert.AreEqual(3, value.AsInt); Assert.AreEqual(3, map["one"].AsInt); } { // pattern matching: extract values out of an array Value value = TestSupport.ToValue("l3.setValue { :key [ :first :second :third ] :value [ 11 22 33 ] :create? true }", scope); Assert.AreEqual(11, scope.AsMap["first"].AsInt); Assert.AreEqual(22, scope.AsMap["second"].AsInt); Assert.AreEqual(33, scope.AsMap["third"].AsInt); } { // special case: initialize every token in array to nil Value value = TestSupport.ToValue("l3.setValue { :key [ :first :second :third ] :value nil :create? true }", scope); Assert.IsTrue(scope.AsMap["first"].IsNil); Assert.IsTrue(scope.AsMap["second"].IsNil); Assert.IsTrue(scope.AsMap["third"].IsNil); } { // if initOnly?, don't overwrite existing values Value value = TestSupport.ToValue("l3.setValue { :key [ :aa :bb ] :value [ 2 3 ] :create? true :initOnly? true }", scope); Assert.AreEqual(2, scope.AsMap["aa"].AsInt); Assert.AreEqual(3, scope.AsMap["bb"].AsInt); value = TestSupport.ToValue("l3.setValue { :key [ :aa :bb ] :value [ 4 5 ] :create? true :initOnly? true }", scope); Assert.AreEqual(2, scope.AsMap["aa"].AsInt); Assert.AreEqual(3, scope.AsMap["bb"].AsInt); value = TestSupport.ToValue("l3.setValue { :key [ :bb :cc ] :value nil :create? true :initOnly? true }", scope); Assert.AreEqual(3, scope.AsMap["bb"].AsInt); Assert.IsTrue(scope.AsMap["cc"].IsNil); } { // if returnSuccess?, return value tells whether a value was set Value value = TestSupport.ToValue("l3.setValue { :key [ :x :y ] :value [ 2 3 ] :returnSuccess? true }", scope); Assert.IsTrue(value.AsBool); value = TestSupport.ToValue("l3.setValue { :key [ :x :y :z ] :value [ 2 3 ] :returnSuccess? true }", scope); Assert.IsFalse(value.AsBool); } }
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; }
public void TestArrayDefault() { List<Value> list = new List<Value>(); list.Add(PatternData.Single("a", ValueType.Int)); list.Add(PatternData.Single("b", new ValueInt(17))); ValueArray pattern = new ValueArray(list); Value match = null, leftover = null; { // single object - not a match Value input = new ValueInt(37); Assert.IsFalse(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); } { // array with one item - match with default added List<Value> one = new List<Value>(); one.Add(new ValueInt(5)); ValueArray input = new ValueArray(one); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsArray.Count); Assert.AreEqual(5, match.AsArray[0].AsInt); Assert.AreEqual(17, match.AsArray[1].AsInt); Assert.AreEqual(null, leftover); } { // array with two items of proper type - match List<Value> two = new List<Value>(); two.Add(new ValueInt(5)); two.Add(new ValueString("hello")); ValueArray input = new ValueArray(two); Assert.IsTrue(PatternChecker.Do(input, pattern, false/*bShortPat*/, out match, out leftover)); Assert.AreEqual(2, match.AsArray.Count); Assert.AreEqual(5, match.AsArray[0].AsInt); Assert.AreEqual("hello", match.AsArray[1].AsString); Assert.AreEqual(null, leftover); } }
/// <summary> /// Define info on the parameters and order the function will get run in /// </summary> /// <param name="previousPattern">if func consumes previous value, this describes the pattern</param> /// <param name="nextPattern">if func consumes next value, this describes the pattern</param> /// <param name="order">evaluation precedence of function within a list</param> protected void Init(Value previousPattern, Value nextPattern, Order order) { Map meta = WritableMetadata; if (previousPattern != null && !previousPattern.IsNil) meta[keyPreviousPattern] = previousPattern; if (nextPattern != null && !nextPattern.IsNil) meta[keyNextPattern] = nextPattern; meta[keyOrder] = new ValueInt((int)order); }
public int GetInt() { ValueInt v = PropValue as ValueInt; return(v != null ? v.Int : 0); }
/// <summary> /// Make a parameter that's an array of two values, /// each of which could be an int or float /// </summary> private DelimiterNode MakePair(double a, double b, bool bInt1, bool bInt2) { List<Value> list = new List<Value>(); Value value1, value2; if (bInt1) value1 = new ValueInt((int)a); else value1 = new ValueFloat(a); list.Add(value1); if (bInt2) value2 = new ValueInt((int)b); else value2 = new ValueFloat(b); list.Add(value2); return new DelimiterNodeValue(new ValueArray(list)); }