/// <summary>
/// Adds a primitive attribute to the class object.
/// </summary>
/// <param name="name">The name of the attribute.</param>
/// <param name="type">The tye of the attribute.</param>
public void AddPrimitiveAttribute(string name, PrimitiveTypes type)
{
PrimitiveAttributes.Add(name, type);
ModelManager.GetInstance().PrimitiveAttributesChanged(this);
ModelManager.GetInstance().StartTranslation();
}
/// <nodoc />
public AmbientDebug(PrimitiveTypes knownTypes)
: base("Debug", knownTypes)
{
m_dataSeparator = Symbol("separator");
m_dataContents = Symbol("contents");
}
public void AddCommand(RenderMaterial material, MaterialAnim anim, Matrix4x4 world, Lighting lights, VertexBuffer buffer, PrimitiveTypes primitive, int baseVertex, int start, int count, int layer, float z = 0, DfmSkinning skinning = null)
{
if (material.IsTransparent)
{
Transparents[transparentCommand++] = new RenderCommand()
{
Source = material,
MaterialAnim = anim,
Lights = lights,
Buffer = buffer,
BaseVertex = baseVertex,
Start = start,
Count = count,
Primitive = primitive,
CmdType = RenderCmdType.Material,
World = world,
SortLayer = layer,
Z = z
};
}
else
{
if (skinning != null)
{
material.Bones = BonesBuffer;
material.BufferOffset = skinning.BufferOffset;
}
else
{
material.Bones = null;
}
material.MaterialAnim = anim;
material.World = world;
material.Use(rstate, buffer.VertexType, ref lights);
buffer.Draw(primitive, baseVertex, start, count);
if (material.DoubleSided)
{
material.FlipNormals = true;
material.UpdateFlipNormals();
rstate.CullFace = CullFaces.Front;
buffer.Draw(primitive, baseVertex, start, count);
rstate.CullFace = CullFaces.Back;
material.FlipNormals = false;
}
}
}
/// <nodoc />
public AmbientString(PrimitiveTypes knownTypes)
: base("String", knownTypes)
{
}
private bool IsPrimitiveType(Type type)
{
if (type == null)
{
return(false);
}
if (type.IsNullable())
{
type = Nullable.GetUnderlyingType(type);
}
return(type.IsPrimitive || type == typeof(string) || type == typeof(Guid) || type.IsEnum || PrimitiveTypes.Any(x => x.IsAssignableFrom(type)));
}
/// <nodoc />
public AmbientArtifactKind(PrimitiveTypes knownTypes)
: base(knownTypes)
{
}
/// <nodoc />
public AmbientRelativePath(PrimitiveTypes knownTypes)
: base("RelativePath", knownTypes)
{
}
/// <nodoc />
public AmbientValueCache(PrimitiveTypes knownTypes)
: base("ValueCache", knownTypes)
{
}
/// <nodoc />
public AmbientNameResolutionSemantics(PrimitiveTypes knownTypes)
: base(knownTypes)
{
}
public static IFunctionConfiguration ReturnsDateTime(this IFunctionConfiguration configuration)
{
return(configuration.ReturnsType(PrimitiveTypes.DateTime()));
}
private bool IsPrimitiveType(Type type, bool includeAdditionalPrimitiveTypes = true)
{
if (type == null)
{
return(false);
}
if (type.IsNullable())
{
type = Nullable.GetUnderlyingType(type);
}
return(type.IsPrimitive || type == typeof(string) || type.IsEnum || (includeAdditionalPrimitiveTypes && PrimitiveTypes.Any(x => x.IsAssignableFrom(type))));
}
public static IFunctionConfiguration ReturnsBinary(this IFunctionConfiguration configuration)
{
return(configuration.ReturnsType(PrimitiveTypes.Binary()));
}
/// <summary>
/// Creates a new primitive type
/// </summary>
/// <param name="primitiveType">The primitive type</param>
public VMType(PrimitiveTypes primitiveType)
: this(ToString(primitiveType))
{
}
/// <summary>
/// Indicates if the current type is of the given primitive type
/// </summary>
/// <param name="primitiveType">The primitive type</param>
public bool IsPrimitiveType(PrimitiveTypes primitiveType)
{
return this.Name == ToString(primitiveType);
}
private static ControlView GetTypeDetails(Type propertyInfo, string guid, ParamValue paramValue = null)
{
bool isNullableType = Nullable.GetUnderlyingType(propertyInfo) != null;
if (
propertyInfo.Name.ToLower() == "dictionary`2" &&
propertyInfo.IsGenericType &&
propertyInfo.GenericTypeArguments != null &&
propertyInfo.GenericTypeArguments.Length == 2)
{
var newParamValues = GetNewParamValues(propertyInfo.Name, paramValue);
var arrayObject = GetTypeDetailsDictionaryObject(propertyInfo, propertyInfo.Name, newParamValues, guid);
return(arrayObject);
}
//for list
else if (propertyInfo.IsArray)
{
int dimensions = propertyInfo.FullName.Split(new[] { "[]" }, StringSplitOptions.None).Length - 1;
Type arrayBaseType = propertyInfo.GetElementType();
for (int ii = 1; ii < dimensions; ii++)
{
arrayBaseType = arrayBaseType.GetElementType();
}
var newParamValues = GetNewParamValues(propertyInfo.Name, paramValue);
var arrayObject = GetTypeDetailsArrayObject(propertyInfo.Name, arrayBaseType, newParamValues, dimensions, guid);
return(arrayObject);
}
else if (propertyInfo.IsPrimitive
// ReSharper disable once PossibleMistakenCallToGetType.2
|| propertyInfo.GetType().IsPrimitive ||
propertyInfo.Name.ToLower() == "string" ||
(isNullableType && PrimitiveTypes.Test(Nullable.GetUnderlyingType(propertyInfo))) ||
PrimitiveTypes.Test(propertyInfo)
)
{
string value = string.Empty;
if (paramValue != null)
{
value = paramValue.Param.ContainsKey(propertyInfo.Name) ? paramValue.Param[propertyInfo.Name] : string.Empty;
if (string.IsNullOrEmpty(value))
{
value = paramValue.Param.ContainsKey("value") ? paramValue.Param["value"] : string.Empty;
}
}
var cv = GetTypeDetailPrimitiveObject(propertyInfo, propertyInfo.Name, isNullableType, value, guid);
return(cv);
}
else
{
ParamValue newParamValues = null;
if (paramValue != null)
{
newParamValues = paramValue;
}
ControlView cv1 = GetTypeDetailComplexObject(propertyInfo, guid, newParamValues);
return(cv1);
}
}
/// <nodoc />
public AmbientDirectory(PrimitiveTypes knownTypes)
: base(Name, knownTypes)
{
}
/// <summary>
/// Returns the name of the given primitive type
/// </summary>
/// <param name="primitiveType">The primitive type</param>
public static string ToString(PrimitiveTypes primitiveType)
{
switch (primitiveType)
{
case PrimitiveTypes.Void:
return "Void";
case PrimitiveTypes.Int:
return "Int";
case PrimitiveTypes.Float:
return "Float";
case PrimitiveTypes.Bool:
return "Bool";
default:
return "";
}
}
/// <summary>
/// Gets the standard collection of values to display in a drop down.
/// </summary>
/// <param name="context">Type descriptor context.</param>
/// <returns>The standard collection of values.</returns>
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
return(new StandardValuesCollection(PrimitiveTypes.GetScannablePrimitiveTypes().Select(x => x.ToString()).ToList()));
}
public override IIsPossibly <IFrontendType> Returns()
{
return(Possibly.Is <IConvertableFrontendType <IVerifiableType> >(PrimitiveTypes.CreateNumberType()));
}
public static void DeclareCursorWithParameters()
{
var query = (SqlQueryExpression)SqlExpression.Parse("SELECT a, b FROM test_table WHERE a / 4 = c");
var statement = new DeclareCursorStatement("c1", new [] { new CursorParameter("c", PrimitiveTypes.Integer()), }, query);
var sql = statement.ToString();
var expected = new SqlStringBuilder();
expected.AppendLine("CURSOR c1(c INTEGER) IS");
expected.Append(" SELECT a, b FROM test_table WHERE a / 4 = c");
Assert.AreEqual(expected.ToString(), sql);
}
public ShaderElementType(PrimitiveTypes t, int d)
{
Type = t;
Dimension = d;
}
/// <nodoc />
public AmbientNumber(PrimitiveTypes knownTypes)
: base("Number", knownTypes)
{
}
public IIsPossibly <IFrontendType> Returns()
{
return(Possibly.Is <IFrontendType>(PrimitiveTypes.CreateNumberType()));
}
protected GraphPrimitive(PrimitiveTypes primitiveType, string displayName)
{
_primitiveType = primitiveType;
_displayName = displayName;
Points = new List <Point>();
}
public static void CreateWithInvalidName(string name, SqlTypeCode typeCode)
{
var type = PrimitiveTypes.Type(typeCode);
Assert.Throws <ArgumentException>(() => new Variable(name, type));
}
public override SqlStatement VisitCreateFunctionStatement(PlSqlParser.CreateFunctionStatementContext context)
{
var functionName = Name.Object(context.objectName());
bool orReplace = context.OR() != null && context.REPLACE() != null;
var body = context.body();
var call = context.callSpec();
SqlType returnType;
var returnTypeSpec = context.functionReturnType();
if (returnTypeSpec.TABLE() != null)
{
returnType = new TabularType();
}
else if (returnTypeSpec.DETERMINISTIC() != null)
{
returnType = Function.DynamicType;
}
else
{
var typeInfo = new DataTypeVisitor().Visit(returnTypeSpec.primitive_type());
if (!typeInfo.IsPrimitive)
{
throw new NotSupportedException(String.Format("The return type of function '{0}' ('{1}') is not primitive.",
functionName, typeInfo));
}
returnType = PrimitiveTypes.Resolve(typeInfo.TypeName, typeInfo.Metadata);
}
RoutineParameter[] parameters = null;
if (context.parameter() != null &&
context.parameter().Length > 0)
{
parameters = context.parameter().Select(Parameter.Routine).ToArray();
}
if (body != null)
{
var functionBody = Visit(body);
if (!(functionBody is PlSqlBody))
{
throw new ParseCanceledException("Invalid function body.");
}
var plsqlBody = ((PlSqlBody)functionBody).AsPlSqlStatement();
var declarationArray = context.declaration();
if (declarationArray != null && declarationArray.Length > 0)
{
foreach (var declContext in declarationArray)
{
var declaration = Visit(declContext);
plsqlBody.Declarations.Add(declaration);
}
}
return(new CreateFunctionStatement(functionName, returnType, parameters, plsqlBody)
{
ReplaceIfExists = orReplace
});
}
var typeString = InputString.AsNotQuoted(call.dotnetSpec().typeString.Text);
var assemblyToken = InputString.AsNotQuoted(call.dotnetSpec().assemblyString);
if (assemblyToken != null)
{
typeString = String.Format("{0}, {1}", typeString, assemblyToken);
}
return(new CreateExternalFunctionStatement(functionName, returnType, parameters, typeString));
}
public void AddCommand(Shader shader, ShaderAction setup, Action <RenderState> cleanup, Matrix4x4 world, Lighting lt, RenderUserData user, VertexBuffer buffer, PrimitiveTypes primitive, int baseVertex, int start, int count, bool transparent, int layer, float z = 0)
{
if (transparent)
{
Transparents[transparentCommand++] = new RenderCommand()
{
Source = shader,
ShaderSetup = setup,
World = world,
UserData = user,
Cleanup = cleanup,
Buffer = buffer,
Lights = lt,
Start = start,
Count = count,
Primitive = primitive,
CmdType = RenderCmdType.Shader,
SortLayer = transparent ? layer : SortLayers.OPAQUE,
Z = z
};
}
else
{
throw new InvalidOperationException();
}
}
private void RegisterAggregates()
{
// COUNT(*)
RegisterAggregate("COUNT", Deterministic("column"), PrimitiveTypes.VarNumeric(),
iterate => {
if (iterate.IsFirst)
{
iterate.SetResult(SqlObject.BigInt(1));
}
else
{
iterate.SetResult(iterate.Accumulation.Add(SqlObject.BigInt(1)));
}
},
initialize => {
var groupResolver = initialize.GetGroupResolver();
var groupSize = groupResolver.Size;
var argRef = (initialize.Input as SqlReferenceExpression)?.ReferenceName;
if (groupSize == 0 || (argRef != null && argRef.IsGlob))
{
initialize.SetResult(SqlExpression.Constant(SqlObject.BigInt(groupSize)), false);
}
return(Task.CompletedTask);
});
// MIN
RegisterAggregate("MIN", Deterministic("column"), PrimitiveTypes.VarNumeric(),
iterate => {
if (iterate.IsFirst)
{
iterate.SetResult(iterate.Current);
}
else if (iterate.Current.LessThan(iterate.Accumulation).IsTrue)
{
iterate.SetResult(iterate.Current);
}
});
// MAX
RegisterAggregate("MAX", Deterministic("column"), PrimitiveTypes.VarNumeric(),
iterate => {
if (iterate.IsFirst)
{
iterate.SetResult(iterate.Current);
}
else if (iterate.Current.GreaterThan(iterate.Accumulation).IsTrue)
{
iterate.SetResult(iterate.Current);
}
else if (iterate.Accumulation.LessThan(iterate.Current).IsTrue)
{
iterate.SetResult(iterate.Accumulation);
}
});
// AVG
RegisterAggregate("AVG", Deterministic("column"), PrimitiveTypes.VarNumeric(),
iterate => {
if (iterate.IsFirst)
{
iterate.SetResult(iterate.Current);
}
else
{
iterate.SetResult(iterate.Current.Add(iterate.Accumulation));
}
}, merge: merge => {
var groupResolver = merge.GetGroupResolver();
var groupSize = groupResolver.Size;
var final = merge.Accumulated.Divide(SqlObject.BigInt(groupSize));
merge.SetOutput(final);
return(Task.CompletedTask);
});
// STDEV
RegisterAggregate("STDEV", Deterministic("column"), PrimitiveTypes.VarNumeric(), iterate => {
var aggregator = (AvgAggregator)iterate.MethodContext.Metadata["aggregator"];
aggregator.Values.Add(iterate.Current);
if (iterate.IsFirst)
{
iterate.SetResult(iterate.Current);
}
else
{
iterate.SetResult(iterate.Current.Add(iterate.Accumulation));
}
}, initialize => {
var groupResolver = initialize.GetGroupResolver();
var aggregator = new AvgAggregator {
Values = new BigList <SqlObject>(groupResolver.Size)
};
initialize.MethodContext.Metadata["aggregator"] = aggregator;
return(Task.CompletedTask);
}, merge => {
var groupResolver = merge.GetGroupResolver();
var groupSize = groupResolver.Size;
var aggregator = (AvgAggregator)merge.MethodContext.Metadata["aggregator"];
var avg = merge.Accumulated.Divide(SqlObject.BigInt(groupSize));
var sums = aggregator.Values.Select(x => SqlMath.Pow((SqlNumber)x.Subtract(avg).Value, (SqlNumber)2));
var sum = SqlNumber.Zero;
foreach (var number in sums)
{
sum += number;
}
var ret = SqlMath.Sqrt(sum / (SqlNumber)(groupSize - 1));
merge.SetOutput(SqlObject.Numeric(ret));
return(Task.CompletedTask);
});
// SUM
RegisterAggregate("SUM", Deterministic("column"), PrimitiveTypes.VarNumeric(),
iterate => {
if (iterate.IsFirst)
{
iterate.SetResult(iterate.Current);
}
else
{
iterate.SetResult(iterate.Current.Add(iterate.Accumulation));
}
});
// LAST
RegisterAggregate("LAST", Deterministic("column"), new SqlDeterministicType(),
iterate => {
var groupResolver = iterate.GetGroupResolver();
var groupSize = groupResolver.Size;
if (iterate.Offset == groupSize - 1)
{
iterate.SetResult(iterate.Current);
}
else
{
iterate.SetResult(SqlObject.Null);
}
});
// FIRST
RegisterAggregate("FIRST", Deterministic("column"), new SqlDeterministicType(),
iterate => {
if (iterate.IsFirst)
{
iterate.SetResult(iterate.Current, false);
}
});
RegisterAggregate("GROUP_ID", PrimitiveTypes.Integer(),
iterate => {
// no-op
}, merge: merge => {
var groupResolver = merge.GetGroupResolver();
merge.SetOutput(SqlObject.Integer(groupResolver.GroupId));
return(Task.CompletedTask);
});
}
//TODO: Implement MaterialAnim for asteroids
public unsafe void AddCommandFade(RenderMaterial material, Matrix4x4 world, Lighting lights, VertexBuffer buffer, PrimitiveTypes primitive, int start, int count, int layer, Vector2 fadeParams, float z = 0)
{
Transparents[transparentCommand++] = new RenderCommand()
{
Source = material,
MaterialAnim = null,
Lights = lights,
Buffer = buffer,
Start = start,
Count = count,
Primitive = primitive,
CmdType = RenderCmdType.MaterialFade,
BaseVertex = *(int *)(&fadeParams.X),
Index = *(int *)(&fadeParams.Y),
World = world,
SortLayer = layer, //Fade is always transparent
Z = z
};
}
/// <nodoc />
public AmbientFile(PrimitiveTypes knownTypes)
: base(FileName, knownTypes)
{
}
protected override IExpression Transform(IExpression Expression)
{
if (Expression is BoxExpression)
{
var boxExpr = (BoxExpression)Expression;
var valType = boxExpr.Value.Type;
if (!PrimitiveTypes.GetIsPrimitive(valType))
{
return(boxExpr.Accept(this));
}
else
{
return(new BoxExpression(
new ReinterpretCastExpression(
Visit(boxExpr.Value),
LookupEquivalentType(valType))));
}
}
else if (Expression is IsExpression)
{
var isExpr = (IsExpression)Expression;
if (!PrimitiveTypes.GetIsPrimitive(isExpr.TestType))
{
return(isExpr.Accept(this));
}
else
{
return(new IsExpression(
Visit(isExpr.Target),
LookupEquivalentType(isExpr.TestType)));
}
}
else if (Expression is UnboxReferenceExpression)
{
var unboxRefExpr = (UnboxReferenceExpression)Expression;
var ptrType = unboxRefExpr.TargetType.AsPointerType();
var elemType = ptrType.ElementType;
if (!PrimitiveTypes.GetIsPrimitive(elemType))
{
return(unboxRefExpr.Accept(this));
}
else
{
return(new ReinterpretCastExpression(
new UnboxReferenceExpression(
Visit(unboxRefExpr.Value),
LookupEquivalentType(elemType).MakePointerType(ptrType.PointerKind)),
unboxRefExpr.TargetType));
}
}
else
{
var unboxExpr = (UnboxValueExpression)Expression;
if (!PrimitiveTypes.GetIsPrimitive(unboxExpr.TargetType))
{
return(unboxExpr.Accept(this));
}
else
{
return(new ReinterpretCastExpression(
new UnboxValueExpression(
Visit(unboxExpr.Value),
LookupEquivalentType(unboxExpr.TargetType)),
unboxExpr.TargetType));
}
}
}
/// <nodoc />
public AmbientTextEncoding(PrimitiveTypes knownTypes)
: base(knownTypes)
{
}
public void AddCommand(Shader shader, ShaderAction setup, Action <RenderState> cleanup, Matrix4 world, RenderUserData user, VertexBuffer buffer, PrimitiveTypes primitive, int start, int count, bool transparent, int layer, float z = 0)
{
if (transparent)
{
Transparents[transparentCommand++] = new RenderCommand()
{
Source = shader,
ShaderSetup = setup,
World = world,
UserData = user,
Cleanup = cleanup,
Buffer = buffer,
Start = start,
Count = count,
Primitive = primitive,
CmdType = RenderCmdType.Shader,
BaseVertex = -1,
SortLayer = transparent ? layer : SortLayers.OPAQUE,
Z = z
};
}
else
{
Commands[currentCommand++] = new RenderCommand()
{
Source = shader,
ShaderSetup = setup,
World = world,
UserData = user,
Cleanup = cleanup,
Buffer = buffer,
Start = start,
Count = count,
Primitive = primitive,
CmdType = RenderCmdType.Shader,
BaseVertex = -1,
SortLayer = transparent ? layer : SortLayers.OPAQUE,
Z = z
};
}
}
/// <summary>
/// Returns the primitive type for the given primitive type
/// </summary>
/// <param name="typeName">The type name</param>
/// <param name="primitiveType">The primitive type</param>
/// <returns>True if primitive type or false</returns>
public static bool FromString(string typeName, out PrimitiveTypes primitiveType)
{
switch (typeName)
{
case "Void":
primitiveType = PrimitiveTypes.Void;
return true;
case "Int":
primitiveType = PrimitiveTypes.Int;
return true;
case "Float":
primitiveType = PrimitiveTypes.Float;
return true;
case "Bool":
primitiveType = PrimitiveTypes.Bool;
return true;
}
primitiveType = PrimitiveTypes.Void;
return false;
}
