public PropertyInfo(VariantType type, string name, PropertyHint hint,
string?hintString, PropertyUsageFlags usage, bool exported)
{
Type = type;
Name = name;
Hint = hint;
HintString = hintString;
Usage = usage;
Exported = exported;
}
private void AppendPropertyConstraint(string sourceVar, PropertyHint propertyHint, string valueVar)
{
if (propertyHint.MappingType == PropertyMappingType.InverseArc)
{
QueryBuilder.AddTripleConstraint(GraphNode.Variable, valueVar, GraphNode.Iri, propertyHint.SchemaTypeUri,
GraphNode.Variable, sourceVar);
}
else
{
QueryBuilder.AddTripleConstraint(GraphNode.Variable, sourceVar, GraphNode.Iri, propertyHint.SchemaTypeUri,
GraphNode.Variable, valueVar);
}
}
protected bool HandleAddressOrIdEquals(Expression left, Expression right)
{
string itemName = null;
PropertyHint propertyHint = GetPropertyHint(left);
if (propertyHint == null ||
!(propertyHint.MappingType == PropertyMappingType.Address ||
propertyHint.MappingType == PropertyMappingType.Id))
{
return(false);
}
if (left is SelectVariableNameExpression)
{
itemName = (left as SelectVariableNameExpression).Name;
}
else if (left is MemberExpression)
{
var m = left as MemberExpression;
if (m.Expression is QuerySourceReferenceExpression)
{
itemName = (m.Expression as QuerySourceReferenceExpression).ReferencedQuerySource.ItemName;
}
else
{
var visitResult = VisitMemberExpression(m);
if (visitResult is SelectVariableNameExpression)
{
itemName = (visitResult as SelectVariableNameExpression).Name;
}
}
}
if (itemName == null)
{
return(false);
}
var constantExpression = right as ConstantExpression;
if (constantExpression == null)
{
return(false);
}
string address = null;
if (propertyHint.MappingType == PropertyMappingType.Id)
{
address = MakeResourceAddress(GetPropertyInfo(left), constantExpression.Value.ToString());
}
else if (propertyHint.MappingType == PropertyMappingType.Address)
{
address = constantExpression.Value.ToString();
}
if (address != null)
{
if (QueryBuilder.SelectVariables.Contains(itemName))
{
QueryBuilder.AddFilterExpression(String.Format("(?{0}=<{1}>)", itemName, address));
}
else
{
QueryBuilder.ConvertVariableToConstantUri(itemName, address);
}
return(true);
}
return(false);
}
public ExportAttribute(PropertyHint hint = PropertyHint.None, string hintString = "")
{
this.hint = hint;
this.hintString = hintString;
}
private void AppendPropertyConstraint(string sourceVar, PropertyHint propertyHint,
ConstantExpression constantExpression)
{
QueryBuilder.AddTripleConstraint(GraphNode.Variable, sourceVar, GraphNode.Iri, propertyHint.SchemaTypeUri, GraphNode.Raw, QueryBuilder.MakeSparqlConstant(constantExpression.Value, false));
}
static bool GetStringArrayEnumHint(VariantType elementVariantType,
AttributeData exportAttr, out string?hintString)
{
var constructorArguments = exportAttr.ConstructorArguments;
if (constructorArguments.Length > 0)
{
var presetHintValue = exportAttr.ConstructorArguments[0].Value;
PropertyHint presetHint = presetHintValue switch
{
null => PropertyHint.None,
int intValue => (PropertyHint)intValue,
_ => (PropertyHint)(long)presetHintValue
};
if (presetHint == PropertyHint.Enum)
{
string?presetHintString = constructorArguments.Length > 1 ?
exportAttr.ConstructorArguments[1].Value?.ToString() :
null;
hintString = (int)elementVariantType + "/" + (int)PropertyHint.Enum + ":";
if (presetHintString != null)
{
hintString += presetHintString;
}
return(true);
}
}
hintString = null;
return(false);
}
if (!isTypeArgument && variantType == VariantType.Array)
{
var elementType = MarshalUtils.GetArrayElementType(type);
if (elementType == null)
{
return(false); // Non-generic Array, so there's no hint to add
}
var elementMarshalType = MarshalUtils.ConvertManagedTypeToMarshalType(elementType, typeCache) !.Value;
var elementVariantType = MarshalUtils.ConvertMarshalTypeToVariantType(elementMarshalType) !.Value;
bool isPresetHint = false;
if (elementVariantType == VariantType.String)
{
isPresetHint = GetStringArrayEnumHint(elementVariantType, exportAttr, out hintString);
}
if (!isPresetHint)
{
bool hintRes = TryGetMemberExportHint(typeCache, elementType,
exportAttr, elementVariantType, isTypeArgument: true,
out var elementHint, out var elementHintString);
// Format: type/hint:hint_string
if (hintRes)
{
hintString = (int)elementVariantType + "/" + (int)elementHint + ":";
if (elementHintString != null)
{
hintString += elementHintString;
}
}
else
{
hintString = (int)elementVariantType + "/" + (int)PropertyHint.None + ":";
}
}
hint = PropertyHint.TypeString;
return(hintString != null);
}
if (!isTypeArgument && variantType == VariantType.PackedStringArray)
{
if (GetStringArrayEnumHint(VariantType.String, exportAttr, out hintString))
{
hint = PropertyHint.TypeString;
return(true);
}
}
if (!isTypeArgument && variantType == VariantType.Dictionary)
{
// TODO: Dictionaries are not supported in the inspector
return(false);
}
return(false);
}
private static bool TryGetMemberExportHint(
MarshalUtils.TypeCache typeCache,
ITypeSymbol type, AttributeData exportAttr,
VariantType variantType, bool isTypeArgument,
out PropertyHint hint, out string?hintString
)
{
hint = PropertyHint.None;
hintString = null;
if (variantType == VariantType.Nil)
{
return(true); // Variant, no export hint
}
if (variantType == VariantType.Int &&
type.IsValueType && type.TypeKind == TypeKind.Enum)
{
bool hasFlagsAttr = type.GetAttributes()
.Any(a => a.AttributeClass?.IsSystemFlagsAttribute() ?? false);
hint = hasFlagsAttr ? PropertyHint.Flags : PropertyHint.Enum;
var members = type.GetMembers();
var enumFields = members
.Where(s => s.Kind == SymbolKind.Field && s.IsStatic &&
s.DeclaredAccessibility == Accessibility.Public &&
!s.IsImplicitlyDeclared)
.Cast <IFieldSymbol>().ToArray();
var hintStringBuilder = new StringBuilder();
var nameOnlyHintStringBuilder = new StringBuilder();
// True: enum Foo { Bar, Baz, Qux }
// True: enum Foo { Bar = 0, Baz = 1, Qux = 2 }
// False: enum Foo { Bar = 0, Baz = 7, Qux = 5 }
bool usesDefaultValues = true;
for (int i = 0; i < enumFields.Length; i++)
{
var enumField = enumFields[i];
if (i > 0)
{
hintStringBuilder.Append(",");
nameOnlyHintStringBuilder.Append(",");
}
string enumFieldName = enumField.Name;
hintStringBuilder.Append(enumFieldName);
nameOnlyHintStringBuilder.Append(enumFieldName);
long val = enumField.ConstantValue switch
{
sbyte v => v,
short v => v,
int v => v,
long v => v,
byte v => v,
ushort v => v,
uint v => v,
ulong v => (long)v,
_ => 0
};
uint expectedVal = (uint)(hint == PropertyHint.Flags ? 1 << i : i);
if (val != expectedVal)
{
usesDefaultValues = false;
}
hintStringBuilder.Append(":");
hintStringBuilder.Append(val);
}
hintString = !usesDefaultValues?
hintStringBuilder.ToString() :
// If we use the format NAME:VAL, that's what the editor displays.
// That's annoying if the user is not using custom values for the enum constants.
// This may not be needed in the future if the editor is changed to not display values.
nameOnlyHintStringBuilder.ToString();
return(true);
}
if (variantType == VariantType.Object && type is INamedTypeSymbol memberNamedType)
{
if (memberNamedType.InheritsFrom("GodotSharp", "Godot.Resource"))
{
string nativeTypeName = memberNamedType.GetGodotScriptNativeClassName() !;
hint = PropertyHint.ResourceType;
hintString = nativeTypeName;
return(true);
}
if (memberNamedType.InheritsFrom("GodotSharp", "Godot.Node"))
{
string nativeTypeName = memberNamedType.GetGodotScriptNativeClassName() !;
hint = PropertyHint.NodeType;
hintString = nativeTypeName;
return(true);
}
}
