/// <summary>
///
/// </summary>
/// <returns></returns>
public IList <string> ToList()
{
List <string> returnList = new List <string>();
returnList.Add(LiteralValue.ToString());
return(returnList);
}
public LiteralExpression(LiteralValue literalValue, int startIndex, int endIndex) : base("Literal", startIndex, endIndex)
{
LiteralValue = literalValue;
var value = literalValue.Value;
ValueType = value == null ? typeof(object) : value.GetType();
}
private FdoRow ConvertValues(FdoRow row)
{
foreach (string propertyName in _rules.Keys)
{
if (row[propertyName] != null)
{
FdoDataPropertyConversionRule rule = _rules[propertyName];
LiteralValue old = ValueConverter.GetConvertedValue(row[propertyName]);
if (old.LiteralValueType == LiteralValueType.LiteralValueType_Data)
{
DataValue converted = ValueConverter.ConvertDataValue((DataValue)old, rule.TargetDataType, rule.NullOnFailure, rule.Truncate);
row[propertyName] = ValueConverter.GetClrValue(converted);
if (converted != null)
{
converted.Dispose();
}
else
{
if (!rule.NullOnFailure)
{
throw new FdoException("Converting " + old + " to " + rule.TargetDataType + " resulted in a NULL value");
}
}
old.Dispose();
}
}
}
return(row);
}
//************************************************************************
//*** FUNCTION add
//*** ********************************************************************
//*** DESCRIPTION : add a literal to the literal table
//*** INPUT ARGS : string literal
//*** OUTPUT ARGS : N/A
//*** IN/OUT ARGS : N/A
//*** RETURN : bool rtnVal
//************************************************************************
public void add(LiteralValue literalValue)
{
int curAddr = literalTable.Count != 0?literalTable.Last.Value.address:0;
literalValue.address = curAddr + literalValue.Length;
literalTable.AddLast(literalValue);
}
public void SerializeFilledCustomDataList()
{
Project p = new Project();
Dictionary <Guid, Guid> emptyMappings = new Dictionary <Guid, Guid>();
Dictionary <Guid, Signal> signals = new Dictionary <Guid, Signal>();
Dictionary <Guid, Bus> buses = new Dictionary <Guid, Bus>();
LiteralValue lv = new LiteralValue("test");
IntegerValue iv = new IntegerValue(42);
ComplexValue cv = new ComplexValue(Constants.Pi, Constants.E);
RealValue rv = new RealValue(Constants.TwoInvSqrtPi);
List <IValueStructure> values = new List <IValueStructure>();
values.Add(lv);
values.Add(iv);
values.Add(cv);
values.Add(rv);
string xml = Serializer.SerializeListToString(values, emptyMappings, emptyMappings, "Structures");
List <IValueStructure> ret = Serializer.DeserializeListFromString <IValueStructure>(xml, signals, buses, "Structures");
Assert.AreEqual(4, ret.Count, "A");
Assert.AreEqual(values[0].TypeId, ret[0].TypeId, "B1");
Assert.AreEqual(values[1].TypeId, ret[1].TypeId, "B2");
Assert.AreEqual(values[2].TypeId, ret[2].TypeId, "B3");
Assert.AreEqual(values[3].TypeId, ret[3].TypeId, "B4");
Assert.AreEqual(values[0].ToString(), ret[0].ToString(), "C1");
Assert.AreEqual(values[1].ToString(), ret[1].ToString(), "C2");
Assert.AreEqual(values[2].ToString(), ret[2].ToString(), "C3");
Assert.AreEqual(values[3].ToString(), ret[3].ToString(), "C4");
}
private static IEnumerable <string> FormatLiteralValue(LiteralValue literalValue)
{
return(new[]
{
literalValue.Value
});
}
private TagValue createTag(Node headNode)
{
if (headNode == null)
{
return(null);
}
var hashNode = GetDescendant(headNode, "hash");
var hash = hashNode == null ? null : resolveRValue(hashNode);
var tag = getTagName(headNode);
var id = getId(headNode);
var classAttrib = getClassAttrib(headNode);
if (tag == null && id == null && classAttrib == null)
{
//empty element declaration
return(null);
}
if (tag == null)
{
//implicit tag
tag = new LiteralValue("div", CurrentContext);
}
return(new TagValue(tag, classAttrib, id, hash, CurrentContext));
}
public string GetLiteralValueAsString()
{
if (LiteralValue == null)
{
return("");
}
return(LiteralValue.ToString());
}
private Signal ScanLiteralSignal()
{
LexerToken token = tokenizer.MatchGet(TokenTypes.Literal);
Signal s = LiteralValue.Constant(token.Text);
system.AddSignal(s);
return(s);
}
public void DoConstructorTest(object value)
{
// Arrange
// Act
LiteralValue result = new LiteralValue(value);
// Assert
Assert.IsNotNull(result);
}
private void DoGetHashCodeTest(object obj)
{
// Arrange
LiteralValue sut = new LiteralValue(obj);
// Act
int result = sut.GetHashCode();
// Assert
}
/// <summary>
/// Fills the list provided with the element matching the filter provided
/// </summary>
/// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
/// <param name="filter">The filter to apply</param>
public void Fill(List <INamable> retVal, BaseFilter filter)
{
if (Designator != null)
{
Designator.Fill(retVal, filter);
}
else if (LiteralValue != null)
{
LiteralValue.Fill(retVal, filter);
}
}
/// <summary>
/// Checks the expression and appends errors to the root tree node when inconsistencies are found
/// </summary>
public void checkExpression()
{
if (Designator != null)
{
Designator.checkExpression();
}
else if (LiteralValue != null)
{
LiteralValue.checkExpression();
}
}
/// <summary>
/// Fills the list provided with the element matching the filter provided
/// </summary>
/// <param name="retVal">The list to be filled with the element matching the condition expressed in the filter</param>
/// <param name="filter">The filter to apply</param>
public void fill(List <Utils.INamable> retVal, Filter.AcceptableChoice filter)
{
if (Designator != null)
{
Designator.fill(retVal, filter);
}
else if (LiteralValue != null)
{
LiteralValue.fill(retVal, filter);
}
}
public void DoEqualityOperatorTest(object a, object b, bool expectedResult)
{
// Arrange
LiteralValue aa = new LiteralValue(a);
LiteralValue bb = new LiteralValue(b);
// Act
bool result = aa == bb;
// Assert
Assert.AreEqual(expectedResult, result);
}
private void DoEqualsTest(object a, object b, bool expected)
{
// Arrange
LiteralValue aa = new LiteralValue(a);
LiteralValue bb = new LiteralValue(b);
// Act
bool result = aa.Equals(bb);
// Assert
Assert.AreEqual(expected, result);
}
private void DoGetLiteralValueTest_Literal(object value, LiteralValue expected)
{
// Arrange
Literal sut = new Literal(value, LiteralType.Value);
// Act
LiteralValue result = sut.GetLiteralValue(null);
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(expected.Equals(result));
}
private void DoGetLiteralValueTest_Token(object value, IDictionary <string, object> state, LiteralValue expected)
{
// Arrange
Literal sut = new Literal(value, LiteralType.Token);
// Act
LiteralValue result = sut.GetLiteralValue(state);
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(expected.Equals(result));
}
public void Day16_TestDecoder_GetLiteralValuePaket_OK()
{
string hexInput = "D2FE28";
var sut = new PaketDecoder(hexInput);
var paket = sut.ParsePaket();
LiteralValue lv = paket as LiteralValue;
Assert.Equal(6, lv.Version);
Assert.Equal(4, lv.TypeID);
Assert.Equal(2021, lv.Value);
}
internal LiteralNode UninterpretedTokenToLNode(ISourceFile file, object value)
{
if (SubstringOffset == 0xFF)
{
var lv = new LiteralValue(value, TypeMarker, TextValue(file.Text));
return(new StdLiteralNode <LiteralValue>(lv, SourceRange.New(file, this), Style));
}
else
{
var lfp = new LiteralFromParser(value, _startIndex + SubstringOffset, _length - SubstringOffset - SubstringOffsetFromEnd, TypeMarker);
return(new StdLiteralNode <LiteralFromParser>(lfp, SourceRange.New(file, this), Style));
}
}
private void DoGetLiteralValueTest_Date(object value)
{
// Arrange
Literal literal = new Literal(value, LiteralType.Date);
LiteralValue lowerBound = new LiteralValue(DateTime.UtcNow.AddMinutes(-1));
LiteralValue upperBound = new LiteralValue(DateTime.UtcNow.AddMinutes(1));
// Act
LiteralValue result = literal.GetLiteralValue(null);
// Assert
Assert.IsTrue(result > lowerBound);
Assert.IsTrue(result < upperBound);
}
//************************************************************************
//*** FUNCTION TryGetLiteral
//*** ********************************************************************
//*** DESCRIPTION : trys to get a literal and returns false on failure
//*** INPUT ARGS : string literal
//*** OUTPUT ARGS : LiteralValue literalValue
//*** IN/OUT ARGS : N/A
//*** RETURN : bool found
//************************************************************************
public bool TryGetLiteral(string literal, out LiteralValue literalValue)
{
literalValue = null;
bool found = false;
foreach (LiteralValue Lit in literalTable.TakeWhile(x => found))
{
if (Lit.label == literal)
{
literalValue = Lit;
found = true;
}
}
return(found);
}
/// <summary>
/// Provides the type of this expression
/// </summary>
/// <param name="context">The interpretation context</param>
/// <returns></returns>
public Types.Type GetExpressionType()
{
Types.Type retVal = null;
if (Designator != null)
{
retVal = Designator.GetDesignatorType();
}
else if (LiteralValue != null)
{
retVal = LiteralValue.GetExpressionType();
}
return(retVal);
}
/// <summary>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <param name="explain"></param>
/// <returns></returns>
public IValue GetValue(InterpretationContext context, ExplanationPart explain)
{
IValue retVal = null;
if (Designator != null)
{
retVal = Designator.GetValue(context);
}
else if (LiteralValue != null)
{
retVal = LiteralValue.GetValue(context, explain);
}
return(retVal);
}
public override string ToString()
{
string retVal = null;
if (Designator != null)
{
retVal = Designator.ToString();
}
else if (LiteralValue != null)
{
retVal = LiteralValue.ToString();
}
return(retVal);
}
/// <summary>
/// Provides the value associated to this Expression
/// </summary>
/// <param name="context">The context on which the value must be found</param>
/// <returns></returns>
public Values.IValue GetValue(InterpretationContext context)
{
Values.IValue retVal = null;
if (Designator != null)
{
retVal = Designator.GetValue(context);
}
else if (LiteralValue != null)
{
retVal = LiteralValue.GetValue(context);
}
return(retVal);
}
private void Expand(LiteralValue literalValue)
{
var value = literalValue.Value;
if (value is int ||
value is float ||
value is double ||
value is decimal)
{
builder.Append(value);
}
else
{
builder.Append('\'').Append(value).Append('\'');
}
}
private FdoRow ConvertValues(FdoRow row)
{
foreach (string propertyName in _rules.Keys)
{
if (row[propertyName] != null)
{
FdoDataPropertyConversionRule rule = _rules[propertyName];
LiteralValue old = ValueConverter.GetConvertedValue(row[propertyName]);
if (old.LiteralValueType == LiteralValueType.LiteralValueType_Data)
{
DataValue converted = ValueConverter.ConvertDataValue((DataValue)old, rule.TargetDataType, rule.NullOnFailure, rule.Truncate);
row[propertyName] = ValueConverter.GetClrValue(converted);
converted.Dispose();
old.Dispose();
}
}
}
return(row);
}
public void ParseOptionCollectionOperate()
{
var values = new ParseOption().LiteralValues;
Assert.False(values.IsReadOnly);
Parallel.For(0, 100, i =>
{
var value = new LiteralValue($"p{i}", i);
values.Add(value);
Assert.True(values.Contains(value));
if (i % 2 == 0)
{
values.Remove(value);
Assert.False(values.Contains(value));
}
});
Assert.Equal(50, values.Count);
Assert.True(values.Skip(10).Take(10).Count(x => (int)(x.Value) % 2 == 0) == 0);
var copies = new LiteralValue[70];
values.CopyTo(copies, 10);
Assert.True(copies.Take(10).Count(x => x == null) == 10);
Assert.True(copies.Skip(10).Take(50).Count(x => x != null) == 50);
Assert.True(copies.Skip(60).Take(10).Count(x => x == null) == 10);
IEnumerable enumerator = values;
foreach (var item in enumerator)
{
Assert.True((int)((item as LiteralValue)?.Value ?? 0) % 2 != 0);
}
Parallel.For(0, 100, i => values.Clear());
Assert.Equal(0, values.Count);
}
public StringField(string key, string mask) : base(key, typeof(string))
{
Mask = new LiteralValue(mask);
}
public void SerializeFilledCustomDataList()
{
Project p = new Project();
Dictionary<Guid, Guid> emptyMappings = new Dictionary<Guid, Guid>();
Dictionary<Guid, Signal> signals = new Dictionary<Guid, Signal>();
Dictionary<Guid, Bus> buses = new Dictionary<Guid, Bus>();
LiteralValue lv = new LiteralValue("test");
IntegerValue iv = new IntegerValue(42);
ComplexValue cv = new ComplexValue(Constants.Pi, Constants.E);
RealValue rv = new RealValue(Constants.TwoInvSqrtPi);
List<IValueStructure> values = new List<IValueStructure>();
values.Add(lv);
values.Add(iv);
values.Add(cv);
values.Add(rv);
string xml = Serializer.SerializeListToString(values, emptyMappings, emptyMappings, "Structures");
List<IValueStructure> ret = Serializer.DeserializeListFromString<IValueStructure>(xml, signals, buses, "Structures");
Assert.AreEqual(4, ret.Count, "A");
Assert.AreEqual(values[0].TypeId, ret[0].TypeId, "B1");
Assert.AreEqual(values[1].TypeId, ret[1].TypeId, "B2");
Assert.AreEqual(values[2].TypeId, ret[2].TypeId, "B3");
Assert.AreEqual(values[3].TypeId, ret[3].TypeId, "B4");
Assert.AreEqual(values[0].ToString(), ret[0].ToString(), "C1");
Assert.AreEqual(values[1].ToString(), ret[1].ToString(), "C2");
Assert.AreEqual(values[2].ToString(), ret[2].ToString(), "C3");
Assert.AreEqual(values[3].ToString(), ret[3].ToString(), "C4");
}
