internal bool TryGenerateValueLeaf(NativeValue nativeValue, out ExpressionSyntax exprSyntax, out ExpressionType type)
{
switch (nativeValue.ValueKind)
{
case NativeValueKind.Number:
type = ExpressionType.Number;
exprSyntax = SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal((int)nativeValue.Value));
return(true);
/*
* case NativeValueKind.Boolean:
* type = ExpressionType.Boolean;
* exprNode = _generator.Literal((bool)nativeValue.Value);
* break;
* case NativeValueKind.Character:
* type = ExpressionType.Char;
* exprNode = _generator.Literal((char)nativeValue.Value);
* break;
* case NativeValueKind.String:
* type = ExpressionType.String;
* exprNode = _generator.Literal((string)nativeValue.Value);
* break;
*/
default:
// TODO: implement
throw new NotSupportedException();
}
}
/// <summary>
/// Adds the given key and value to the table.
/// </summary>
/// <param name="key">The key to be added. If the key is an index, start at 1 because LUA can't work with indexes at 0</param>
/// <param name="val">The value to be added</param>
public void Add(object key, object val)
{
NativeValue nKey = Bridge.CreateNValue(key);
NativeValue nVal = Bridge.CreateNValue(val);
Onset.AddValueToTable(NVal.NativePtr, nKey.NativePtr, nVal.NativePtr);
}
public void IsValueResolved1()
{
NativeValue val = NativeValue.CreateBoolean(true);
Assert.True(val.IsValueResolved);
val.Value = null;
Assert.False(val.IsValueResolved);
}
public void Resolve2()
{
NativeValue val = NativeValue.CreateString("foo");
Assert.Equal("foo", Convert.ToString(val.Value));
Assert.Equal(NativeValueKind.String, val.ValueKind);
Assert.True(val.IsImmediateResolved);
}
public void Resolve7()
{
NativeValue val = NativeValue.CreateCharacter('c');
Assert.Equal("c", Convert.ToString(val.Value));
Assert.Equal(NativeValueKind.Character, val.ValueKind);
Assert.True(val.IsImmediateResolved);
}
public void Resolve1()
{
NativeValue val = NativeValue.CreateNumber(1);
Assert.Equal(1, Convert.ToInt32(val.Value));
Assert.Equal(NativeValueKind.Number, val.ValueKind);
Assert.True(val.IsImmediateResolved);
}
public void IsValueResolved2()
{
NativeValue val = NativeValue.CreateCharacter('c');
Assert.True(val.IsValueResolved);
val.Value = null;
Assert.False(val.IsValueResolved);
}
public void Dynamic1()
{
NativeValue val = NativeValue.CreateNumber(1);
Assert.Equal(NativeValueKind.Number, val.ValueKind);
val.Value = 42;
Assert.Equal(NativeValueKind.Number, val.ValueKind);
Assert.Equal(42, Convert.ToInt32(val.Value));
}
public void Dynamic2()
{
NativeValue val = NativeValue.CreateNumber(42);
Assert.Equal(NativeValueKind.Number, val.ValueKind);
val.Value = "foo";
Assert.Equal(NativeValueKind.Number, val.ValueKind);
Assert.Equal("foo", Convert.ToString(val.Value));
}
public void Resolve6()
{
NativeValue val = NativeValue.CreateSymbolType("foo", new NativeBuiltinType(BuiltinType.NativeBoolean));
Assert.Equal("foo", val.Name);
Assert.Equal(NativeValueKind.SymbolType, val.ValueKind);
Assert.Null(val.SymbolValue);
Assert.NotNull(val.SymbolType);
Assert.True(val.IsImmediateResolved);
}
public void IsValueResolved5()
{
NativeValue val = NativeValue.CreateSymbolValue("foo");
Assert.False(val.IsValueResolved);
val.Value = new NativeStruct("foo");
Assert.True(val.IsValueResolved);
val.Value = null;
Assert.False(val.IsValueResolved);
}
public void Resolve4()
{
NativeValue val = NativeValue.CreateSymbolValue("bar");
Assert.Equal("bar", val.Name);
Assert.Equal(NativeValueKind.SymbolValue, val.ValueKind);
Assert.True(val.IsImmediateResolved);
val.Value = new NativeBuiltinType(BuiltinType.NativeByte);
Assert.True(val.IsImmediateResolved);
}
public void IsValueResolved3()
{
NativeValue val = NativeValue.CreateNumber(42);
Assert.True(val.IsValueResolved);
val.Value = null;
Assert.False(val.IsValueResolved);
val.Value = 42;
Assert.True(val.IsValueResolved);
}
private object GetInternal(object key)
{
if (key is int idx)
{
key = idx + 1;
}
NativeValue nKey = Bridge.CreateNValue(key);
return(new NativeValue(Onset.GetValueFromTable(NVal.NativePtr, nKey.NativePtr)).GetValue());
}
protected override void OnUpdate()
{
NativeValue <float3, SummedFloat3Operator> avgPosition = new NativeValue <float3, SummedFloat3Operator>(Allocator.TempJob);
NativeValue <float3, SummedFloat3Operator> .ParallelWriter avgPositionParallelWriter = avgPosition.AsParallelWriter();
JobHandle jobHandle = Entities.WithName("AvgPositionJob")
.WithStoreEntityQueryInField(ref localToWorldQuery)
.ForEach((in LocalToWorld localToWorld) =>
{
avgPositionParallelWriter.CombineWith(localToWorld.Position);
}).ScheduleParallel(default);
private static IDataType NativeValueToDataType(ServerProcess process, NativeValue nativeValue)
{
NativeScalarValue nativeScalar = nativeValue as NativeScalarValue;
if (nativeScalar != null)
{
return(NativeTypeNameToDataType(process.DataTypes, nativeScalar.DataTypeName));
}
NativeListValue nativeList = nativeValue as NativeListValue;
if (nativeList != null)
{
return
(new ListType
(
// Use the element type name if given
!String.IsNullOrEmpty(nativeList.ElementDataTypeName)
? NativeTypeNameToDataType(process.DataTypes, nativeList.ElementDataTypeName)
// If not, try to use the type of the first element
: (nativeList.Elements != null && nativeList.Elements.Length > 0 && String.IsNullOrEmpty(nativeList.ElementDataTypeName))
? NativeValueToDataType(process, nativeList.Elements[0])
// If not, revert to generic list
: process.DataTypes.SystemGeneric
));
}
NativeRowValue nativeRow = nativeValue as NativeRowValue;
if (nativeRow != null)
{
return(new Schema.RowType(NativeColumnsToColumns(process.DataTypes, nativeRow.Columns)));
}
NativeTableValue nativeTable = nativeValue as NativeTableValue;
if (nativeTable != null)
{
TableType tableType = new TableType();
foreach (Column column in NativeColumnsToColumns(process.DataTypes, nativeTable.Columns))
{
tableType.Columns.Add(column);
}
return(tableType);
}
throw new NotSupportedException(String.Format("Values of type \"{0}\" are not supported.", nativeTable.GetType().Name));
}
public List <NativeValue> FindUnresolvedNativeValues()
{
List <NativeValue> list = new List <NativeValue>();
foreach (NativeSymbol ns in this.FindAllReachableNativeSymbols())
{
NativeValue nValue = ns as NativeValue;
if (nValue != null && !nValue.IsValueResolved)
{
list.Add(nValue);
}
}
return(list);
}
public void Value5()
{
NativeValueExpression expr = new NativeValueExpression("(DWORD)5");
Assert.Equal(2, expr.Values.Count);
NativeValue val = expr.Values[0];
Assert.Equal(NativeValueKind.SymbolType, val.ValueKind);
Assert.Equal("DWORD", val.DisplayValue);
val = expr.Values[1];
Assert.Equal(NativeValueKind.Number, val.ValueKind);
Assert.Equal(5, Convert.ToInt32(val.Value));
}
public NativeValue ToNativeValue(JavaRuntime runtime, object value)
{
NativeValue val = new NativeValue();
if (value is string)
{
string str = value.ToString();
val.l = runtime.JavaEnvironment.JNIEnv.NewString(str, str.Length);
return(val);
}
Type type = val.GetType();
foreach (FieldInfo fieldInfo in type.GetFields())
{
if (fieldInfo.FieldType == value.GetType())
{
fieldInfo.SetValue(val, value);
}
}
return(val);
}
private CodeExpression GenerateValueExpressionLeaf(ExpressionNode node, ref CodeTypeReference leafType)
{
ThrowIfNull(node);
var ntVal = NativeValue.TryCreateForLeaf(node, _bag);
if (ntVal == null)
{
throw new InvalidOperationException("Expected a NativeValue");
}
if (!ntVal.IsValueResolved)
{
throw new InvalidOperationException(string.Format("Value {0} is not resolved", ntVal.Name));
}
switch (ntVal.ValueKind)
{
case NativeValueKind.Number:
leafType = new CodeTypeReference(ntVal.Value.GetType());
return(new CodePrimitiveExpression(ntVal.Value));
case NativeValueKind.Boolean:
leafType = new CodeTypeReference(typeof(bool));
return(new CodePrimitiveExpression(ntVal.Value));
case NativeValueKind.String:
leafType = new CodeTypeReference(typeof(string));
return(new CodePrimitiveExpression(ntVal.Value));
case NativeValueKind.Character:
leafType = new CodeTypeReference(typeof(char));
return(new CodePrimitiveExpression(ntVal.Value));
case NativeValueKind.SymbolValue:
NativeSymbol ns = ntVal.SymbolValue;
// Prevent the generation of a circular reference
if (_symbolValueMap.ContainsKey(ns.Name))
{
leafType = new CodeTypeReference(typeof(object));
return(new CodePrimitiveExpression(null));
}
switch (ns.Kind)
{
case NativeSymbolKind.Constant:
leafType = CalculateConstantType((NativeConstant)ns);
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(TransformConstants.NativeConstantsName), ns.Name));
case NativeSymbolKind.EnumType:
leafType = this.GenerateTypeReference((NativeEnum)ns);
return(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(ns.Name), ntVal.Name));
default:
throw new InvalidOperationException(string.Format("Generation of {0} not supported as a value", ns.Kind));
}
case NativeValueKind.SymbolType:
throw new InvalidOperationException("Types are not supported as leaf nodes");
default:
ThrowInvalidEnumValue(ntVal.ValueKind);
return(null);
}
}
public static IDataValue NativeValueToDataValue(ServerProcess process, NativeValue nativeValue)
{
NativeScalarValue nativeScalar = nativeValue as NativeScalarValue;
if (nativeScalar != null)
{
return(new Scalar(process.ValueManager, (IScalarType)NativeTypeNameToDataType(process.DataTypes, nativeScalar.DataTypeName), nativeScalar.Value));
}
NativeListValue nativeList = nativeValue as NativeListValue;
if (nativeList != null)
{
// Create and fill the list
ListValue list = new ListValue(process.ValueManager, (ListType)NativeValueToDataType(process, nativeValue), nativeList.Elements == null ? null : new NativeList());
if (nativeList.Elements != null && nativeList.Elements.Length > 0)
{
for (int index = 0; index < nativeList.Elements.Length; index++)
{
list.Add(NativeValueToDataValue(process, nativeList.Elements[index]));
}
}
return(list);
}
NativeRowValue nativeRow = nativeValue as NativeRowValue;
if (nativeRow != null)
{
Row row = new Row(process.ValueManager, new Schema.RowType(NativeColumnsToColumns(process.DataTypes, nativeRow.Columns)));
if (nativeRow.Values == null)
{
row.AsNative = null;
}
else
{
for (int index = 0; index < nativeRow.Values.Length; index++)
{
row[index] = NativeValueToDataValue(process, nativeRow.Values[index]);
}
}
return(row);
}
NativeTableValue nativeTable = nativeValue as NativeTableValue;
if (nativeTable != null)
{
NativeTable internalTable = new NativeTable(process.ValueManager, NativeTableToTableVar(process, nativeTable));
TableValue table = new TableValue(process.ValueManager, internalTable.TableType, internalTable);
if (nativeTable.Rows == null)
{
table.AsNative = null;
}
else
{
bool[] valueTypes = new bool[internalTable.TableType.Columns.Count];
for (int index = 0; index < internalTable.TableType.Columns.Count; index++)
{
valueTypes[index] = internalTable.TableType.Columns[index].DataType is IScalarType;
}
for (int index = 0; index < nativeTable.Rows.Length; index++)
{
Row row = new Row(process.ValueManager, internalTable.RowType);
try
{
for (int columnIndex = 0; columnIndex < nativeTable.Rows[index].Length; columnIndex++)
{
if (valueTypes[columnIndex])
{
row[columnIndex] = nativeTable.Rows[index][columnIndex];
}
else
{
row[columnIndex] = NativeValueToDataValue(process, (NativeValue)nativeTable.Rows[index][columnIndex]);
}
}
internalTable.Insert(process.ValueManager, row);
}
catch (Exception)
{
row.Dispose();
throw;
}
}
}
return(table);
}
throw new NotSupportedException(String.Format("Unknown native value type: \"{0}\".", nativeValue.GetType().Name));
}
private static string GetDataTypeName(NativeValue value)
{
NativeScalarValue scalarValue = value as NativeScalarValue;
if (scalarValue != null)
{
return(scalarValue.DataTypeName);
}
NativeListValue listValue = value as NativeListValue;
if (listValue != null)
{
return(String.Format("list({0})", listValue.ElementDataTypeName));
}
NativeRowValue rowValue = value as NativeRowValue;
if (rowValue != null)
{
var sb = new StringBuilder();
sb.Append("row{");
bool first = true;
foreach (NativeColumn column in rowValue.Columns)
{
if (!first)
{
sb.Append(",");
}
else
{
first = false;
}
sb.AppendFormat("{0}:{1}", column.Name, column.DataTypeName);
}
sb.Append("}");
return(sb.ToString());
}
NativeTableValue tableValue = value as NativeTableValue;
if (tableValue != null)
{
var sb = new StringBuilder();
sb.Append("table{");
bool first = true;
foreach (NativeColumn column in tableValue.Columns)
{
if (!first)
{
sb.Append(",");
}
else
{
first = false;
}
sb.AppendFormat("{0}:{1}", column.Name, column.DataTypeName);
}
sb.Append("}");
return(sb.ToString());
}
throw new NotSupportedException("Non-scalar-valued attributes are not supported.");
}
public LuaTable()
{
NVal = new NativeValue(Onset.CreateNValueTable());
}
public override int GetHashCode()
{
return(NativeValue.GetHashCode());
}
internal LuaTable(IntPtr ptr)
{
NVal = new NativeValue(ptr);
}
internal LuaTable(NativeValue nVal)
{
NVal = nVal;
}
/// <summary>
/// Checks if the given key is present in this table.
/// </summary>
/// <param name="key">The key to be checked</param>
/// <returns>True if the key is present</returns>
public bool ContainsKey(object key)
{
NativeValue nKey = Bridge.CreateNValue(key);
return(Onset.ContainsTableKey(NVal.NativePtr, nKey.NativePtr));
}
/// <summary>
/// Removes the key and the associated value in the table.
/// </summary>
/// <param name="key">The key which should be removed</param>
public void Remove(object key)
{
NativeValue nKey = Bridge.CreateNValue(key);
Onset.RemoveTableKey(NVal.NativePtr, nKey.NativePtr);
}
public override string ToString() => NativeValue?.ToString();
