public void AddCmp(Type cmp)
{
ContextSwitchInterpreter inter = new ContextSwitchInterpreter(cmp, Engine);
Debug.Log("context " + inter.Engine);
ops.AddInterpreter(NameTranslator.ScriptNameFromCSharp(cmp.Name), inter);
}
public override void Init()
{
var cmpTypes = Engine.FindTypesCastableTo <MonoBehaviour> ();
foreach (var cmp in cmpTypes)
{
string scriptName = NameTranslator.ScriptNameFromCSharp(cmp.Name);
components.Add(scriptName, cmp);
HasComponentScope scope = new HasComponentScope();
scope.Type = cmp;
scope.ExprInter = this;
scopeInterpreters.Add("has_" + scriptName, scope);
scope.Engine = this.Engine;
}
var specTypes = Engine.FindTypesWithAttribute <ScopeInterpreterAttribute> ();
foreach (var specType in specTypes)
{
ScopeInterpreter inter = Activator.CreateInstance(specType.Type) as ScopeInterpreter;
inter.Engine = this.Engine;
inter.ExprInter = this;
scopeInterpreters.Add(specType.Attribute.Name, inter);
}
//string closure = InterpretClosure ();
}
public ContextSwitchInterpreter(Type type, ScriptEngine engine)
{
this.Engine = engine;
engine.GetPlugin <ContextSwitchesPlugin> ().AddInterToType(type, this);
//if (ScriptEngine.AnalyzeDebug)
// Debug.Log ("Context switch " + type);
contextType = type;
if (type == typeof(GameObject))
{
return;
}
var props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
foreach (var prop in props)
{
//Debug.Log (prop.Name);
if (prop.PropertyType != typeof(string) && (prop.PropertyType.IsClass || (prop.PropertyType.IsValueType && !prop.PropertyType.IsEnum &&
prop.PropertyType != typeof(bool) && prop.PropertyType != typeof(float) && prop.PropertyType != typeof(int))) &&
!(prop.PropertyType.IsGenericType && prop.PropertyType.GetGenericTypeDefinition() == typeof(List <>)))
{
ContextPropertySwitchInterpreter inter = new ContextPropertySwitchInterpreter(prop.Name, prop.PropertyType, engine);
contextSwitches.Add(NameTranslator.ScriptNameFromCSharp(prop.Name), inter);
inter.Engine = Engine;
//if (ScriptEngine.AnalyzeDebug)
// Debug.Log ("SubContext " + NameTranslator.ScriptNameFromCSharp (prop.Name));
}
else
{
ContextPropertyInterpreter inter = new ContextPropertyInterpreter(prop.Name, prop.PropertyType, Engine);
inter.Engine = Engine;
//if (ScriptEngine.AnalyzeDebug)
// Debug.Log (inter.Engine);
properties.Add(NameTranslator.ScriptNameFromCSharp(prop.Name), inter);
//if (ScriptEngine.AnalyzeDebug)
// Debug.Log (NameTranslator.ScriptNameFromCSharp (prop.Name));
}
}
foreach (var method in methods)
{
if (method.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).Length > 0)
{
continue;
}
// if (ScriptEngine.AnalyzeDebug)
// Debug.Log ("Context method " + method.Name);
ContextFunctionCallInterpreter inter = new ContextFunctionCallInterpreter(method, Engine);
try
{
functions.Add(NameTranslator.ScriptNameFromCSharp(method.Name), inter);
}
catch (ArgumentException e)
{
Debug.LogWarningFormat("{0} has a duplicate function named {1}", type, method.Name);
}
}
}
private InvocationExpressionSyntax BuildTableIndexForBuilder(IRelationalDatabaseTable table, IDatabaseIndex index)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
if (index == null)
{
throw new ArgumentNullException(nameof(index));
}
var columns = index.Columns.SelectMany(c => c.DependentColumns).ToList();
var schemaNamespace = NameTranslator.SchemaToNamespace(table.Name);
var className = NameTranslator.TableToClassName(table.Name);
var qualifiedClassName = !schemaNamespace.IsNullOrWhiteSpace()
? schemaNamespace + "." + className
: className;
var entity = GetEntityBuilder(qualifiedClassName);
var indexBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
entity,
IdentifierName(nameof(EntityTypeBuilder.HasIndex))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
GenerateColumnSet(className, columns, false)))));
if (index.IsUnique)
{
indexBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
indexBuilder,
IdentifierName(nameof(IndexBuilder.IsUnique))));
}
if (index.Name != null)
{
indexBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
indexBuilder,
IdentifierName(nameof(RelationalIndexBuilderExtensions.HasName))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(index.Name.LocalName))))));
}
return(indexBuilder);
}
public GameObject SpawnPrefab(string name)
{
GameObject prefab = null;
if (!prefabs.TryGetValue(name, out prefab))
{
var csharpname = NameTranslator.CSharpNameFromScript(name);
prefab = Resources.Load("UIPrefabs/" + csharpname) as GameObject;
prefabs.Add(name, prefab);
}
return(GameObject.Instantiate(prefab));
}
private PropertyDeclarationSyntax BuildParentKey(IEnumerable <IRelationalDatabaseTable> tables, IDatabaseRelationalKey relationalKey, Option <IRelationalDatabaseTableComments> comment, string className, string propertyName)
{
if (tables == null)
{
throw new ArgumentNullException(nameof(tables));
}
if (relationalKey == null)
{
throw new ArgumentNullException(nameof(relationalKey));
}
if (className.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(className));
}
if (propertyName.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(propertyName));
}
var parentTable = relationalKey.ParentTable;
var parentSchemaName = NameTranslator.SchemaToNamespace(parentTable);
var parentClassName = NameTranslator.TableToClassName(parentTable);
var qualifiedParentName = !parentSchemaName.IsNullOrWhiteSpace()
? parentSchemaName + "." + parentClassName
: parentClassName;
var foreignKeyIsNotNull = relationalKey.ChildKey.Columns.All(c => !c.IsNullable);
var parentTypeName = foreignKeyIsNotNull
? ParseTypeName(qualifiedParentName)
: NullableType(ParseTypeName(qualifiedParentName));
var property = PropertyDeclaration(
parentTypeName,
Identifier(propertyName)
);
var foreignKey = property
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.VirtualKeyword)))
.WithAccessorList(SyntaxUtilities.PropertyGetSetDeclaration)
.WithLeadingTrivia(BuildForeignKeyComment(relationalKey, comment));
if (!foreignKeyIsNotNull)
{
return(foreignKey);
}
return(foreignKey
.WithInitializer(SyntaxUtilities.NotNullDefault)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
}
void Awake()
{
if (!provided)
{
FindObjectOfType <BasicLoader>().EFunctions.Add(new BasicLoader.ExternalFunctions(this, "GetSpace"));
provided = true;
}
if (SceneSpace)
{
hardcodedSpaces.Add(NameTranslator.ScriptNameFromCSharp(gameObject.name), this);
}
Places = new List <Place> ();
}
private PropertyDeclarationSyntax BuildColumn(IRelationalDatabaseTable table, IDatabaseColumn column, Option <IRelationalDatabaseTableComments> comment, string className)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
if (column == null)
{
throw new ArgumentNullException(nameof(column));
}
if (className.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(className));
}
var clrType = column.Type.ClrType;
var propertyName = NameTranslator.ColumnToPropertyName(className, column.Name.LocalName);
var columnTypeSyntax = column.IsNullable
? NullableType(ParseTypeName(clrType.FullName))
: ParseTypeName(clrType.FullName);
if (clrType.Namespace == nameof(System) && SyntaxUtilities.TypeSyntaxMap.ContainsKey(clrType.Name))
{
columnTypeSyntax = column.IsNullable
? NullableType(SyntaxUtilities.TypeSyntaxMap[clrType.Name])
: SyntaxUtilities.TypeSyntaxMap[clrType.Name];
}
var baseProperty = PropertyDeclaration(
columnTypeSyntax,
Identifier(propertyName)
);
var columnSyntax = baseProperty
.AddAttributeLists(BuildColumnAttributes(table, column, propertyName).ToArray())
.WithModifiers(SyntaxTokenList.Create(Token(SyntaxKind.PublicKeyword)))
.WithAccessorList(SyntaxUtilities.PropertyGetSetDeclaration)
.WithLeadingTrivia(BuildColumnComment(column.Name, comment));
var isNotNullRefType = !column.IsNullable && !column.Type.ClrType.IsValueType;
if (!isNotNullRefType)
{
return(columnSyntax);
}
return(columnSyntax
.WithInitializer(SyntaxUtilities.NotNullDefault)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
}
private string GetQualifiedClassName(Identifier objectName)
{
if (objectName == null)
{
throw new ArgumentNullException(nameof(objectName));
}
var schemaNamespace = NameTranslator.SchemaToNamespace(objectName);
var className = NameTranslator.ViewToClassName(objectName);
return(!schemaNamespace.IsNullOrWhiteSpace()
? schemaNamespace + "." + className
: className);
}
public DB2ColumnTransformer(Table table, Column involvedColumn,DB2TableTransformer dependingTransformer,NameTranslator nameTranslator)
: this(table,nameTranslator)
{
this._involvedColumn = involvedColumn;
this._dependingTransformer = dependingTransformer;
_column = new Column((DB_EA.Table)table, involvedColumn.name);
_column.type = involvedColumn.type;
_column.logicalAttribute = ((DB_EA.Column)involvedColumn).logicalAttribute;
if (dependingTransformer.associationEnd != null)
{
if (dependingTransformer.associationEnd.lower > 0 )
{
_column.isNotNullable = true;
}
}
}
/// <summary>
/// Generates source code that enables interoperability with a given database table for Entity Framework Core.
/// </summary>
/// <param name="tables">The database tables in the database.</param>
/// <param name="table">A database table.</param>
/// <param name="comment">Comment information for the given table.</param>
/// <returns>A string containing source code to interact with the table.</returns>
/// <exception cref="ArgumentNullException"><paramref name="tables"/> or <paramref name="table"/> is <c>null</c>.</exception>
public override string Generate(IReadOnlyCollection <IRelationalDatabaseTable> tables, IRelationalDatabaseTable table, Option <IRelationalDatabaseTableComments> comment)
{
if (tables == null)
{
throw new ArgumentNullException(nameof(tables));
}
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
var schemaNamespace = NameTranslator.SchemaToNamespace(table.Name);
var tableNamespace = !schemaNamespace.IsNullOrWhiteSpace()
? Namespace + "." + schemaNamespace
: Namespace;
var namespaces = table.Columns
.Select(c => c.Type.ClrType.Namespace)
.Where(ns => ns != tableNamespace)
.Union(new[]
{
"System.Collections.Generic",
"System.ComponentModel.DataAnnotations",
"System.ComponentModel.DataAnnotations.Schema"
})
.Distinct()
.OrderNamespaces()
.ToList();
var usingStatements = namespaces
.Select(ns => ParseName(ns))
.Select(UsingDirective)
.ToList();
var namespaceDeclaration = NamespaceDeclaration(ParseName(tableNamespace));
var classDeclaration = BuildClass(tables, table, comment);
var document = CompilationUnit()
.WithUsings(List(usingStatements))
.WithMembers(
SingletonList <MemberDeclarationSyntax>(
namespaceDeclaration
.WithMembers(
SingletonList <MemberDeclarationSyntax>(classDeclaration))));
using var workspace = new AdhocWorkspace();
return(Formatter.Format(document, workspace).ToFullString());
}
private InvocationExpressionSyntax BuildTableUniqueKeyForBuilder(IRelationalDatabaseTable table, IDatabaseKey uniqueKey)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
if (uniqueKey == null)
{
throw new ArgumentNullException(nameof(uniqueKey));
}
var schemaNamespace = NameTranslator.SchemaToNamespace(table.Name);
var className = NameTranslator.TableToClassName(table.Name);
var qualifiedClassName = !schemaNamespace.IsNullOrWhiteSpace()
? schemaNamespace + "." + className
: className;
var entity = GetEntityBuilder(qualifiedClassName);
var ukBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
entity,
IdentifierName(nameof(EntityTypeBuilder.HasAlternateKey))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
GenerateColumnSet(className, uniqueKey.Columns, false)))));
uniqueKey.Name.IfSome(ukName =>
{
ukBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ukBuilder,
IdentifierName(nameof(RelationalKeyBuilderExtensions.HasName))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(ukName.LocalName))))));
});
return(ukBuilder);
}
private ClassDeclarationSyntax BuildClass(IRelationalDatabaseTable table, Option <IRelationalDatabaseTableComments> comment)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
var className = NameTranslator.TableToClassName(table.Name);
var properties = table.Columns
.Select(c => BuildColumn(c, comment, className))
.ToList();
return(ClassDeclaration(className)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithLeadingTrivia(BuildTableComment(table.Name, comment))
.WithMembers(List <MemberDeclarationSyntax>(properties)));
}
public override void Init()
{
ops = Engine.GetPlugin <EventFunctionOperators> ();
var components = Engine.FindTypesCastableTo <MonoBehaviour> ();
MaxProgress = components.Count;
foreach (var cmp in components)
{
CurProgress++;
ContextSwitchInterpreter inter = new ContextSwitchInterpreter(cmp, Engine);
//if (ScriptEngine.AnalyzeDebug)
// Debug.Log ("context " + inter.Engine);
ops.AddInterpreter(NameTranslator.ScriptNameFromCSharp(cmp.Name), inter);
}
CurProgress = MaxProgress;
var goInter = new ContextSwitchInterpreter(typeof(GameObject), Engine);
}
private ClassDeclarationSyntax BuildClass(IDatabaseView view, Option <IDatabaseViewComments> comment)
{
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
var className = NameTranslator.ViewToClassName(view.Name);
var properties = view.Columns
.Select(vc => BuildColumn(vc, comment, className))
.ToList();
return(ClassDeclaration(className)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithLeadingTrivia(BuildViewComment(view.Name, comment))
.WithMembers(List <MemberDeclarationSyntax>(properties)));
}
private SimpleLambdaExpressionSyntax GenerateColumnSet(string className, IEnumerable <IDatabaseColumn> columns, bool suppressNullable)
{
if (columns == null)
{
throw new ArgumentNullException(nameof(columns));
}
var columnsList = columns.ToList();
if (columnsList.Count == 1)
{
var column = columnsList[0];
var propertyName = NameTranslator.ColumnToPropertyName(className, column.Name.LocalName);
return(SimpleLambdaExpression(
Parameter(
Identifier(EntityLambdaParameterName)),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
suppressNullable
? PostfixUnaryExpression(
SyntaxKind.SuppressNullableWarningExpression,
IdentifierName(EntityLambdaParameterName))
: IdentifierName(EntityLambdaParameterName) as ExpressionSyntax,
IdentifierName(propertyName))));
}
var columnsSet = columns
.Select(c =>
AnonymousObjectMemberDeclarator(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
suppressNullable
? PostfixUnaryExpression(
SyntaxKind.SuppressNullableWarningExpression,
IdentifierName(EntityLambdaParameterName))
: IdentifierName(EntityLambdaParameterName) as ExpressionSyntax,
IdentifierName(NameTranslator.ColumnToPropertyName(className, c.Name.LocalName)))))
.ToList();
return(SimpleLambdaExpression(
Parameter(
Identifier(EntityLambdaParameterName)),
AnonymousObjectCreationExpression(
SeparatedList(columnsSet))));
}
public void Init(Type dataType, string dir)
{
this.dir = dir;
this.dataType = dataType;
var props = dataType.GetProperties();
foreach (var prop in props)
{
var dataArg = Expression.Parameter(typeof(T), "data");
var contentArg = Expression.Parameter(typeof(object), "content");
var conDataArg = Expression.Convert(dataArg, dataType);
var conContentArg = Expression.Convert(contentArg, prop.PropertyType);
var assignProp = Expression.Call(conDataArg, prop.GetSetMethod(), conContentArg);
var lambda = Expression.Lambda <LoadFromNodeContentDelegate> (assignProp, dataArg, contentArg);
var call = lambda.Compile();
properties.Add(NameTranslator.ScriptNameFromCSharp(prop.Name), call);
}
}
public static bool SelectAccount(System.Windows.Forms.IWin32Window parent, string targetComputerName, ref string acctName, out bool isGroup, out bool isService, out string sid)
{
const Locations defLoc = Locations.EnterpriseDomain | Locations.ExternalDomain | Locations.GlobalCatalog | Locations.JoinedDomain | Locations.LocalComputer;
var dlg = new DirectoryObjectPickerDialog
{
TargetComputer = targetComputerName,
MultiSelect = false,
SkipDomainControllerCheck = true,
AllowedLocations = defLoc,
DefaultLocations = defLoc,
AllowedObjectTypes = ObjectTypes.Users // | ObjectTypes.WellKnownPrincipals | ObjectTypes.Computers;
};
if (NativeMethods.AccountUtils.CurrentUserIsAdmin(targetComputerName))
{
dlg.AllowedObjectTypes |= ObjectTypes.BuiltInGroups | ObjectTypes.Groups | ObjectTypes.WellKnownPrincipals;
}
dlg.DefaultObjectTypes = dlg.AllowedObjectTypes;
dlg.AttributesToFetch.Add("objectSid");
var res = System.Windows.Forms.DialogResult.None;
try { res = dlg.ShowDialog(parent); } catch { }
if (res == System.Windows.Forms.DialogResult.OK)
{
if (dlg.SelectedObject != null)
{
try
{
acctName = !string.IsNullOrEmpty(dlg.SelectedObject.Upn) ? NameTranslator.TranslateUpnToDownLevel(dlg.SelectedObject.Upn) : dlg.SelectedObject.Name;
}
catch
{
acctName = dlg.SelectedObject.Name;
}
sid = AttrToString(dlg.SelectedObject.FetchedAttributes[0]);
isGroup = dlg.SelectedObject.SchemaClassName.Equals("Group", StringComparison.OrdinalIgnoreCase);
isService = NativeMethods.AccountUtils.UserIsServiceAccount(acctName);
return(true);
}
}
isGroup = isService = false;
sid = null;
return(false);
}
private PropertyDeclarationSyntax BuildTableDbSet(IRelationalDatabaseTable table)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
var schemaNamespace = NameTranslator.SchemaToNamespace(table.Name);
var className = NameTranslator.TableToClassName(table.Name);
var qualifiedClassName = !schemaNamespace.IsNullOrWhiteSpace()
? schemaNamespace + "." + className
: className;
var setName = className.Pluralize();
var qualifiedTableName = !table.Name.Schema.IsNullOrWhiteSpace()
? table.Name.Schema + "." + table.Name.LocalName
: table.Name.LocalName;
return(BuildDbSetProperty(qualifiedClassName, setName, qualifiedTableName, "table"));
}
private PropertyDeclarationSyntax BuildViewDbSet(IDatabaseView view)
{
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
var schemaNamespace = NameTranslator.SchemaToNamespace(view.Name);
var className = NameTranslator.ViewToClassName(view.Name);
var qualifiedClassName = !schemaNamespace.IsNullOrWhiteSpace()
? schemaNamespace + "." + className
: className;
var setName = className.Pluralize();
var qualifiedViewName = !view.Name.Schema.IsNullOrWhiteSpace()
? view.Name.Schema + "." + view.Name.LocalName
: view.Name.LocalName;
return(BuildDbSetProperty(qualifiedClassName, setName, qualifiedViewName, "view"));
}
/// <summary>
/// Generates source code that enables interoperability with a given database view for OrmLite.
/// </summary>
/// <param name="view">A database view.</param>
/// <param name="comment">Comment information for the given view.</param>
/// <returns>A string containing source code to interact with the view.</returns>
/// <exception cref="ArgumentNullException"><paramref name="view"/> is <c>null</c>.</exception>
public override string Generate(IDatabaseView view, Option <IDatabaseViewComments> comment)
{
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
var schemaNamespace = NameTranslator.SchemaToNamespace(view.Name);
var viewNamespace = !schemaNamespace.IsNullOrWhiteSpace()
? Namespace + "." + schemaNamespace
: Namespace;
var namespaces = new[] { "ServiceStack.DataAnnotations" }
.Union(
view.Columns
.Select(c => c.Type.ClrType.Namespace)
.Where(ns => ns != viewNamespace)
)
.Distinct()
.OrderNamespaces()
.ToList();
var usingStatements = namespaces
.Select(ns => ParseName(ns))
.Select(UsingDirective)
.ToList();
var namespaceDeclaration = NamespaceDeclaration(ParseName(viewNamespace));
var classDeclaration = BuildClass(view, comment);
var document = CompilationUnit()
.WithUsings(List(usingStatements))
.WithMembers(
SingletonList <MemberDeclarationSyntax>(
namespaceDeclaration
.WithMembers(
SingletonList <MemberDeclarationSyntax>(classDeclaration))));
using var workspace = new AdhocWorkspace();
return(Formatter.Format(document, workspace).ToFullString());
}
private ClassDeclarationSyntax BuildClass(IEnumerable <IRelationalDatabaseTable> tables, IRelationalDatabaseTable table, Option <IRelationalDatabaseTableComments> comment)
{
if (tables == null)
{
throw new ArgumentNullException(nameof(tables));
}
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
var className = NameTranslator.TableToClassName(table.Name);
var columnProperties = table.Columns
.Select(c => BuildColumn(c, comment, className))
.ToList();
var usedNames = new StringHashSet(table.Columns.Select(c => NameTranslator.ColumnToPropertyName(table.Name.LocalName, c.Name.LocalName)));
var parentKeyProperties = table.ParentKeys.Select(fk =>
{
var candidatePropertyName = NameTranslator.TableToClassName(fk.ParentTable);
var propertyName = GenerateUniqueName(usedNames, candidatePropertyName);
return(BuildParentKey(tables, fk, comment, className, propertyName));
});
var childKeyProperties = table.ChildKeys.Select(ck =>
{
var candidatePropertyName = NameTranslator.TableToClassName(ck.ChildTable).Pluralize();
var propertyName = GenerateUniqueName(usedNames, candidatePropertyName);
return(BuildChildKey(tables, ck, className, propertyName));
});
var properties = columnProperties.Concat(parentKeyProperties).Concat(childKeyProperties);
return(ClassDeclaration(className)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.AddAttributeLists(BuildClassAttributes(table, className).ToArray())
.WithLeadingTrivia(BuildTableComment(table.Name, comment))
.WithMembers(List <MemberDeclarationSyntax>(properties)));
}
public override void Interpret(Operator op, FunctionBlock block)
{
if (exprInter == null)
{
exprInter = Engine.GetPlugin <ExpressionInterpreter>();
}
if (op.Args.Count > 0 && op.Args[0].Operands[0] is ExprAtom &&
(op.Args[0].Operands[0] as ExprAtom).Content is Scope &&
((op.Args[0].Operands[0] as ExprAtom).Content as Scope).Parts.Count == 1)
{
var part = ((op.Args[0].Operands[0] as ExprAtom).Content as Scope).Parts[0];
if (!(part is string))
{
Debug.Log("Wrong remove_from definition");
return;
}
var listName = NameTranslator.CSharpNameFromScript(part as string);
DeclareVariableStatement declareVar = block.FindStatement <DeclareVariableStatement>(v => v.IsContext && v.Type.GetProperty(listName) != null);
//Debug.Log (declareVar.DebugString ());
if (declareVar == null)
{
Debug.Log("remove_from operator can't find context variable");
}
else
{
if (op.Context is Expression)
{
var exprValue = exprInter.InterpretExpression(op.Context as Expression, block);
//block = exprValue.NotNullBlock;
block.Statements.Add(String.Format("{0}.{1}.Remove({2});", declareVar.Name, listName, exprValue.ExprString));
}
}
}
else
{
Debug.Log("Wrong remove_from definition");
}
}
public override void Init()
{
FiltersPlugin filtersPlugin = Engine.GetPlugin <FiltersPlugin> ();
var components = Engine.FindTypesCastableTo <MonoBehaviour> ();
foreach (var cmp in components)
{
var cmpName = NameTranslator.ScriptNameFromCSharp(cmp.Name);
var opName = "has_" + cmpName;
HasComponentFilter filter = new HasComponentFilter(cmp);
filtersPlugin.AddFilter(filter, opName);
}
var specTypes = Engine.FindTypesWithAttribute <FilterPartInterpreterAttribute> ();
foreach (var specType in specTypes)
{
FilterPartInterpreter inter = Activator.CreateInstance(specType.Type) as FilterPartInterpreter;
inter.Engine = this.Engine;
filtersPlugin.AddFilter(inter, specType.Attribute.Name);
}
}
private string CanonicalToDistinguishedName(string cn)
{
string domain = null;
int slash = cn.IndexOf(Backslash);
if (slash > -1)
{
domain = cn.Substring(0, slash);
}
if (_translator == null)
{
_translator = new NameTranslator();
}
_translator.Credential = CurrentCredential;
_translator.Domain = CurrentRootInfo.Path.ToDomainNameString(false);
_translator.Server = CurrentRootInfo.Server;
cn = cn.Replace(Backslash, Slash);
return(_translator.CanonicalToDistinguishedName(cn));
}
public EADatabaseTransformer(DatabaseFactory factory, UTF_EA.Model model,NameTranslator nameTranslator)
: base(nameTranslator)
{
this._factory = factory;
this._model = model;
}
void CreateEventFunction(string name, object context, CodeTypeDeclaration codeType, MethodInfo baseMethod, params object[] initStatements)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Name = NameTranslator.CSharpNameFromScript(name);
method.Attributes = MemberAttributes.Override | MemberAttributes.Public;
method.ReturnType = new CodeTypeReference(baseMethod.ReturnType);
var args = baseMethod.GetParameters();
FunctionBlock block = new FunctionBlock(null, method, codeType);
block.Statements.Add("var root = this.root;");
//block.Statements.Add ("UnityEngine.Debug.Log(root.ToString() + IfStatement.AntiMergeValue++);");
var externVar = new DeclareVariableStatement()
{
Name = "External",
IsArg = true,
Type = Engine.GetType("External")
};
block.Statements.Add(externVar);
block.Statements.Add(new ContextStatement()
{
ContextVar = externVar,
InterpretInContext = Engine.GetPlugin <ExternalFunctionsPlugin>().Ctx.InterpretInContext
});
foreach (var initStmt in initStatements)
{
block.Statements.Add(initStmt);
}
//bool hasRoot = false;
foreach (var arg in args)
{
//if (arg.Name == "root")
// hasRoot = true;
method.Parameters.Add(new CodeParameterDeclarationExpression(arg.ParameterType, arg.Name));
var paramVar = new DeclareVariableStatement();
paramVar.Name = arg.Name;
paramVar.Type = arg.ParameterType;
paramVar.IsArg = true;
block.Statements.Add(paramVar);
}
var rootVar = new DeclareVariableStatement();
rootVar.Name = "root";
rootVar.Type = typeof(GameObject);
rootVar.IsArg = true;
block.Statements.Add(rootVar);
foreach (var member in codeType.Members)
{
var field = member as CodeMemberField;
if (field != null)
{
var cachedVar = new DeclareVariableStatement();
cachedVar.Name = field.Name;
cachedVar.Type = field.UserData ["type"] as Type;
cachedVar.IsArg = true;
block.Statements.Add(cachedVar);
}
}
//if (!hasRoot)
//{
// Debug.LogFormat ("Method {0} in {1} has no root arg", baseMethod.Name, codeType.Name);
// return;
//}
codeType.Members.Add(method);
var table = context as Context;
if (table != null)
{
foreach (var entry in table.Entries)
{
Operator op = entry as Operator;
var inter = functionOperators.GetInterpreter(op, block);
if (inter == null)
{
Debug.LogFormat("Can't find interpreter for operator {0} in {1} of {2}", op.Identifier, baseMethod.Name, codeType.Name);
continue;
}
inter.Interpret(op, block);
}
var retVal = block.FindStatement <DeclareVariableStatement> (v => v.IsReturn);
if (retVal != null)
{
block.Statements.Add(String.Format("return {0};", retVal.Name));
}
}
else
{
var expr = context as Expression;
var retVal = block.FindStatement <DeclareVariableStatement> (v => v.IsReturn);
//retVal.IsArg = true;
block.Statements.Add(String.Format("return ({1}){0};", exprInter.InterpretExpression(expr, block).ExprString, TypeName.NameOf(retVal.Type)));
}
method.Statements.Add(new CodeSnippetStatement(block.ToString()));
}
public EATableTransformer(Database database, NameTranslator nametranslator)
: base(nametranslator)
{
_database = database;
}
public DB2ForeignKeyTransformer(Table table, List <Column> FKInvolvedColumns, DB2TableTransformer dependingTransformer, UTF_EA.AssociationEnd associationEnd, NameTranslator nameTranslator) : base(nameTranslator)
{
this._foreignKey = new ForeignKey((Table)table, FKInvolvedColumns);
this._foreignKey.foreignTable = dependingTransformer.table;
this._logicalAssociationEnd = associationEnd;
//get the association on which this foreign key is based
if (associationEnd != null)
{
this._foreignKey.logicalAssociation = (UTF_EA.Association)associationEnd.association;
}
table.constraints.Add(this._foreignKey);
//reset the name of the foreign key
resetName();
//make sure we get the correct override settings for the FK and the involved columns
var dummy = this._foreignKey.isOverridden;
}
public DB2DatabaseTransformer(DatabaseFactory factory,UTF_EA.Model model,NameTranslator nameTranslator)
: base(factory,model,nameTranslator)
{
this._externalDatabase = factory.createDatabase("external");
}
// static Dictionary<Type, ContextPropertySwitchInterpreter> switchesByType = new Dictionary<Type, ContextPropertySwitchInterpreter> ();
//
// public static ContextPropertySwitchInterpreter GetSwitch (Type t)
// {
// ContextPropertySwitchInterpreter inter = null;
// if (!switchesByType.TryGetValue (t, out inter))
// {
//
//
// }
// return inter;
// }
public ContextPropertySwitchInterpreter(string propName, Type type, ScriptEngine engine) : base(propName, type, engine)
{
engine.GetPlugin <ContextSwitchesPlugin> ().AddInterToType(type, this);
this.propName = propName;
propType = type;
this.Engine = engine;
// if (ScriptEngine.AnalyzeDebug)
// Debug.Log ("Context switch " + type);
var props = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
// if (ScriptEngine.AnalyzeDebug)
// Debug.Log ("Methods count " + methods.Length);
var thisKey = new PropKey(type, propName);
if (!allPropSwitches.ContainsKey(thisKey))
{
allPropSwitches.Add(thisKey, this);
}
if (typeof(MonoBehaviour).IsAssignableFrom(type) && type != typeof(MonoBehaviour))
{
//if (ScriptEngine.AnalyzeDebug)
// Debug.Log ("It's a component! " + type);
foreach (var prop in props)
{
//Debug.Log (prop.Name);
if (prop.PropertyType != typeof(string) && (prop.PropertyType.IsClass || (prop.PropertyType.IsValueType && !prop.PropertyType.IsEnum &&
prop.PropertyType != typeof(bool) && prop.PropertyType != typeof(float) && prop.PropertyType != typeof(int))))
{
var key = new PropKey(prop.PropertyType, prop.Name);
if (allPropSwitches.ContainsKey(key))
{
contextSwitches.Add(NameTranslator.ScriptNameFromCSharp(prop.Name), allPropSwitches [key]);
}
else
{
ContextPropertySwitchInterpreter inter = new ContextPropertySwitchInterpreter(prop.Name, prop.PropertyType, engine);
contextSwitches.Add(NameTranslator.ScriptNameFromCSharp(prop.Name), inter);
inter.Engine = Engine;
}
// if (ScriptEngine.AnalyzeDebug)
// Debug.Log ("SubContext " + NameTranslator.ScriptNameFromCSharp (prop.Name));
}
else
{
ContextPropertyInterpreter inter = new ContextPropertyInterpreter(prop.Name, prop.PropertyType, engine);
inter.Engine = Engine;
// if (ScriptEngine.AnalyzeDebug)
// Debug.Log (inter.Engine);
properties.Add(NameTranslator.ScriptNameFromCSharp(prop.Name), inter);
// if (ScriptEngine.AnalyzeDebug)
// Debug.Log (NameTranslator.ScriptNameFromCSharp (prop.Name));
}
}
foreach (var method in methods)
{
if (method.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).Length > 0)
{
continue;
}
// if (ScriptEngine.AnalyzeDebug)
// Debug.Log ("Context method " + method.Name);
ContextFunctionCallInterpreter inter = new ContextFunctionCallInterpreter(method, Engine);
functions.Add(NameTranslator.ScriptNameFromCSharp(method.Name), inter);
}
}
}
public DB2PrimaryKeyTransformer(Table table, List<Column> involvedColumns,NameTranslator nameTranslator)
: base(table,nameTranslator)
{
this._table.primaryKey = new DB_EA.PrimaryKey((DB_EA.Table)table, involvedColumns);
resetName();
}
private InvocationExpressionSyntax BuildTableChildKeyForBuilder(IRelationalDatabaseTable table, IDatabaseRelationalKey relationalKey)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
if (relationalKey == null)
{
throw new ArgumentNullException(nameof(relationalKey));
}
var schemaNamespace = NameTranslator.SchemaToNamespace(table.Name);
var className = NameTranslator.TableToClassName(table.Name);
var qualifiedClassName = !schemaNamespace.IsNullOrWhiteSpace()
? schemaNamespace + "." + className
: className;
var childSetName = className.Pluralize();
var childKey = relationalKey.ChildKey;
var parentPropertyName = NameTranslator.TableToClassName(relationalKey.ParentTable);
var entity = GetEntityBuilder(qualifiedClassName);
var parentKeyBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
entity,
IdentifierName(nameof(EntityTypeBuilder.HasOne))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
SimpleLambdaExpression(
Parameter(
Identifier(EntityLambdaParameterName)),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(EntityLambdaParameterName),
IdentifierName(parentPropertyName)))))));
parentKeyBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
parentKeyBuilder,
IdentifierName(nameof(ReferenceNavigationBuilder.WithMany))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
SimpleLambdaExpression(
Parameter(
Identifier(EntityLambdaParameterName)),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
PostfixUnaryExpression(
SyntaxKind.SuppressNullableWarningExpression,
IdentifierName(EntityLambdaParameterName)),
IdentifierName(childSetName)))))));
parentKeyBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
parentKeyBuilder,
IdentifierName(nameof(ReferenceCollectionBuilder.HasForeignKey))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
GenerateColumnSet(className, childKey.Columns, false)))));
parentKeyBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
parentKeyBuilder,
IdentifierName(nameof(ReferenceCollectionBuilder.HasPrincipalKey))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
GenerateColumnSet(className, relationalKey.ParentKey.Columns, true)))));
relationalKey.ChildKey.Name.IfSome(childKeyName =>
{
parentKeyBuilder = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
parentKeyBuilder,
IdentifierName(nameof(RelationalForeignKeyBuilderExtensions.HasConstraintName))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(childKeyName.LocalName))))));
});
return(parentKeyBuilder);
}
public EAForeignKeyTransformer(ForeignKey foreignKey, UTF_EA.Association association,NameTranslator nameTranslator)
: this(nameTranslator)
{
_foreignKey = foreignKey;
_logicalAssociation = association;
}
private InvocationExpressionSyntax BuildTableColumnPropertyForBuilder(IRelationalDatabaseTable table, IDatabaseColumn column)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
if (column == null)
{
throw new ArgumentNullException(nameof(column));
}
var schemaNamespace = NameTranslator.SchemaToNamespace(table.Name);
var className = NameTranslator.TableToClassName(table.Name);
var qualifiedClassName = !schemaNamespace.IsNullOrWhiteSpace()
? schemaNamespace + "." + className
: className;
var entity = GetEntityBuilder(qualifiedClassName);
var propertyName = NameTranslator.ColumnToPropertyName(className, column.Name.LocalName);
var property = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
entity,
IdentifierName(nameof(EntityTypeBuilder.Property))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
SimpleLambdaExpression(
Parameter(
Identifier(EntityLambdaParameterName)),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(EntityLambdaParameterName),
IdentifierName(propertyName)))))));
column.DefaultValue.IfSome(def =>
{
property = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
property,
IdentifierName(nameof(RelationalPropertyBuilderExtensions.HasDefaultValue))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(def))))));
});
if (column.IsComputed && column is IDatabaseComputedColumn computedColumn)
{
computedColumn.Definition.IfSome(def =>
{
property = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
property,
IdentifierName(nameof(RelationalPropertyBuilderExtensions.HasComputedColumnSql))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(def))))));
});
}
return(property);
}
public EAPrimaryKeyTransformer(Table table, NameTranslator nameTranslator)
: base(nameTranslator)
{
_table = table;
}
public DB2DatabaseTransformer(UTF_EA.Package logicalPackage,NameTranslator nameTranslator)
: this(logicalPackage.model, nameTranslator)
{
this._logicalPackage = logicalPackage;
}
public DB2DatabaseTransformer(UTF_EA.Model model,NameTranslator nameTranslator)
: this(getFactory(model),model,nameTranslator)
{
}
public DB2ColumnTransformer(Table table,NameTranslator nameTranslator)
: base(table,nameTranslator)
{
}
public EAForeignKeyTransformer(NameTranslator nameTranslator)
: base(nameTranslator)
{
_nameTranslator = nameTranslator;
}
public DB2ColumnTransformer(Table table, Column column, UTF_EA.Attribute attribute,NameTranslator nameTranslator)
: this(table,nameTranslator)
{
this.logicalProperty = attribute;
this.column = column;
}
/// <summary>
/// constructor
/// </summary>
/// <param name="database">the database the table should belong to</param>
/// <param name="nameTranslator">the nametranslator</param>
public DB2TableTransformer(Database database,NameTranslator nameTranslator)
: base(database,nameTranslator)
{
}
public DB2ForeignKeyTransformer(ForeignKey foreignKey, UTF_EA.AssociationEnd associationEnd, NameTranslator nameTranslator) : base(foreignKey, associationEnd, nameTranslator)
{
}
public EAColumnTransformer(Table table, NameTranslator nameTranslator)
: base(nameTranslator)
{
this._table = table;
}
public EADatabaseItemTransformer(NameTranslator nameTranslator)
{
_nameTranslator = nameTranslator;
}
