private IDictionary <string, string> GenerateBases(CodeGenerationInfo generationInfo)
{
var codes = new Dictionary <string, string>();
var assembly = System.Reflection.Assembly.GetExecutingAssembly();
var ns = string.Join(".", assembly.GetName().Name, "reader");
var files = assembly.GetManifestResourceNames().Where(item => item.StartsWith(ns) && (item.EndsWith(".h") || item.EndsWith(".cpp"))).ToArray();
foreach (var item in files)
{
var value = this.GetResourceString(item);
var extension = Path.GetExtension(item).Replace(".", "[.]");
var key = Regex.Replace(item, "(^" + this.GetType().Namespace + @"[.])(\S+)" + extension, "$2").Replace('.', Path.DirectorySeparatorChar);
//var name = item.Replace("Ntreev.Crema.Runtime.Generation.NativeC.", string.Empty);
//var stream = new StreamReader(assembly.GetManifestResourceStream(item));
//var text = stream.ReadToEnd();
//stream.Dispose();
value = this.ChangeReadNamespace(value, generationInfo);
codes.Add(key + Path.GetExtension(item), value);
}
var cremaBase = this.GenerateBaseHeader(generationInfo);
var cremaBaseCpp = this.GenerateBaseCpp(generationInfo);
codes.Add("crema_base.h", cremaBase);
codes.Add("crema_base.cpp", cremaBaseCpp);
return(codes);
}
public static void Create(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetTables())
{
Create(codeNamespace, item, generationInfo);
}
}
public IDictionary <string, string> Generate(CodeGenerationInfo generationInfo)
{
var codes = new Dictionary <string, string>();
var codeDomProvider = new CodeDom.NativeCCodeProvider();
var options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = generationInfo.BlankLinesBetweenMembers;
options.BracingStyle = "C";
options.ElseOnClosing = false;
options.IndentString = IndentedTextWriter.DefaultTabString;
options["CustomGeneratorOptionStringExampleID"] = "BuildFlags: /A /B /C /D /E";
ColumnInfoExtensions.TypeNamespace = generationInfo.Namespace;
var cremaTypes = GenerateTypes(codeDomProvider, options, generationInfo);
var cremaTables = GenerateTables(codeDomProvider, options, generationInfo);
string cremaTypesHeader, cremaTypesCpp;
string cremaTablesHeader, cremaTablesCpp;
SplitCode(cremaTypes, $"{generationInfo.Prefix}types{generationInfo.Postfix}.h", out cremaTypesHeader, out cremaTypesCpp);
SplitCode(cremaTables, $"{generationInfo.Prefix}tables{generationInfo.Postfix}.h", out cremaTablesHeader, out cremaTablesCpp);
codes.Add($"{generationInfo.Prefix}types{generationInfo.Postfix}.h", cremaTypesHeader);
codes.Add($"{generationInfo.Prefix}types{generationInfo.Postfix}.cpp", cremaTypesCpp);
codes.Add($"{generationInfo.Prefix}tables{generationInfo.Postfix}.h", cremaTablesHeader);
codes.Add($"{generationInfo.Prefix}tables{generationInfo.Postfix}.cpp", cremaTablesCpp);
return(codes);
}
private static CodeTypeDeclaration CreateCore(TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration();
classType.Name = tableInfo.GetClassName();
classType.IsClass = true;
classType.BaseTypes.Add(generationInfo.BaseNamespace, "CremaTable", tableInfo.GetRowCodeType(CodeType.None));
if (generationInfo.NoComment == false)
{
classType.Comments.AddSummary(tableInfo.Comment);
}
if (generationInfo.NoChanges == false)
{
classType.Comments.Add(CremaSchema.Creator, tableInfo.CreationInfo.ID);
classType.Comments.Add(CremaSchema.CreatedDateTime, tableInfo.CreationInfo.DateTime);
classType.Comments.Add(CremaSchema.Modifier, tableInfo.ModificationInfo.ID);
classType.Comments.Add(CremaSchema.ModifiedDateTime, tableInfo.ModificationInfo.DateTime);
classType.Comments.Add(CremaSchema.ContentsModifier, tableInfo.ContentsInfo.ID);
classType.Comments.Add(CremaSchema.ContentsModifiedDateTime, tableInfo.ContentsInfo.DateTime);
}
CreateCreateRowInstanceMethod(classType, tableInfo, generationInfo);
CreateFields(classType, tableInfo, generationInfo);
CreateConstructor(classType, tableInfo, generationInfo);
CreateConstructorFromTable(classType, tableInfo, generationInfo);
CreateConstructorFromRows(classType, tableInfo);
CreateDestructor(classType, tableInfo, generationInfo);
CreateFindMethod(classType, tableInfo, generationInfo);
return(classType);
}
private static void CreateLoadFromFile(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cc = new CodeMemberMethod();
cc.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cc.Name = "Load";
var codeTypeRef = new CodeTypeReference(typeof(string));
codeTypeRef.SetCodeType(CodeType.Reference | CodeType.Const);
cc.Parameters.Add(codeTypeRef, "filename");
cc.Parameters.Add(new CodeTypeReference(typeof(bool)), "verifyRevision");
var paramExp = new CodeVariableReferenceExpression("filename");
var readerTypeRef = new CodeTypeReferenceExpression(string.Join("::", generationInfo.ReaderNamespace, "CremaReader"));
var readerInvokeExp = new CodeMethodInvokeExpression(readerTypeRef, "ReadFromFile", paramExp);
var methodInvokeExp = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Load", readerInvokeExp, new CodeVariableReferenceExpression("verifyRevision"));
cc.Statements.Add(methodInvokeExp);
//cc.ChainedConstructorArgs.Add(methodInvokeExp);
//cc.ChainedConstructorArgs.Add(new CodeVariableReferenceExpression("verifyRevision"));
classType.Members.Add(cc);
}
private string GenerateBaseCpp(CodeGenerationInfo generationInfo)
{
var assembly = System.Reflection.Assembly.GetExecutingAssembly();
var resourceName = string.Join(".", assembly.GetName().Name, "code", "crema_base.cpp");
var code = this.GetResourceString(resourceName);
return(this.ChangeBaseNamespace(code, generationInfo));
}
private static void CreateTagsField(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmf = new CodeMemberField();
cmf.Attributes = MemberAttributes.Private;
cmf.Name = "_tags";
cmf.Type = new CodeTypeReference(typeof(string));
classType.Members.Add(cmf);
}
private static void CreateFieldsTable(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetTables(true))
{
var cmf = new CodeMemberField();
cmf.Attributes = MemberAttributes.Public;
cmf.Name = item.Name;
cmf.Type = item.GetCodeType(CodeType.Pointer | CodeType.Const);
classType.Members.Add(cmf);
}
}
private static void CreateTagsMethod(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Name = "tags";
cmm.ReturnType = new CodeTypeReference(typeof(string));
cmm.Statements.AddMethodReturn(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "_tags"));
classType.Members.Add(cmm);
}
private string ChangeBaseNamespace(string text, CodeGenerationInfo generationInfo)
{
var segments = generationInfo.BaseNamespace.Split(new string[] { "::", }, StringSplitOptions.RemoveEmptyEntries);
var firstNamespace = string.Join(" { ", segments.Select(item => "namespace " + item));
var lastNamespace = string.Join(" ", segments.Select(item => "} /*namespace " + item + "*/"));
var first = "namespace CremaCode";
var last = "} /*namespace CremaCode*/";
text = text.Replace(last, lastNamespace);
text = text.Replace(first, firstNamespace);
return(text);
}
private static void CreateDestructor(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cc = new CodeDestructor();
cc.Attributes = MemberAttributes.Public | MemberAttributes.Override;
foreach (var item in generationInfo.GetTables())
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), item.Name);
var delete = new CodeObjectDeleteExpression(field);
cc.Statements.Add(delete);
}
classType.Members.Add(cc);
}
public void Generate(string outputPath, GenerationSet metaData, CodeGenerationSettings settings)
{
var generationInfo = new CodeGenerationInfo(metaData, settings)
{
RelativePath = string.Empty,
};
if (settings.BasePath != string.Empty)
{
var relativePath = UriUtility.MakeRelativeOfDirectory(new DirectoryInfo(outputPath).FullName, DirectoryUtility.GetAbsolutePath(outputPath, settings.BasePath));
generationInfo.RelativePath = relativePath + "/";
}
{
var codes = this.Generate(generationInfo);
var dirInfo = new DirectoryInfo(outputPath);
var rootPath = generationInfo.Namespace.Replace('.', Path.DirectorySeparatorChar);
foreach (var item in codes)
{
var ext = Path.GetExtension(item.Key);
var filename = FileUtility.RemoveExtension(item.Key).Replace('.', Path.DirectorySeparatorChar) + ext;
filename = Path.Combine(dirInfo.FullName, filename);
FileUtility.Prepare(filename);
using (StreamWriter sw = new StreamWriter(filename, false, Encoding.UTF8))
{
sw.WriteLine(item.Value);
this.PrintResult(filename);
}
}
}
if (settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == false)
{
var codes = this.GenerateBases(generationInfo);
var codesPath = DirectoryUtility.GetAbsolutePath(outputPath, settings.BasePath);
foreach (var item in codes)
{
var codePath = FileUtility.Prepare(codesPath, item.Key);
using (var writer = new StreamWriter(codePath, false, Encoding.UTF8))
{
writer.WriteLine(item.Value);
this.PrintResult(codePath);
}
}
}
}
public static void Create(CodeNamespace codeNamespace, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetChilds(tableInfo))
{
if (item.TemplatedParent != string.Empty)
{
continue;
}
Create(codeNamespace, item, generationInfo);
}
CremaRowClassCreator.Create(codeNamespace, tableInfo, generationInfo);
var classType = CreateCore(tableInfo, generationInfo);
codeNamespace.Types.Add(classType);
}
public static void Create(CodeNamespace codeNamespace, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration();
codeNamespace.Types.Add(classType);
classType.IsClass = true;
classType.Name = tableInfo.GetRowClassName();
classType.BaseTypes.Add(generationInfo.BaseNamespace, "CremaRow");
CreateColumnFields(classType, tableInfo, generationInfo);
CreateTableField(classType, tableInfo);
CreateChildFields(classType, tableInfo, generationInfo);
CreateStaticChildEmptyFields(classType, tableInfo, generationInfo);
CreateParentField(classType, tableInfo);
CreateConstructor(classType, tableInfo, generationInfo);
CreateSetChildsMethod(classType, tableInfo, generationInfo);
}
public static void Create(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo)
{
codeNamespace.Comments.Add(new CodeCommentStatement($"------------------------------------------------------------------------------"));
codeNamespace.Comments.Add(new CodeCommentStatement($"dataBase: {generationInfo.DataBaseName}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"revision: {generationInfo.Revision}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"requested revision: {generationInfo.RequestedRevision}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"devmode: {generationInfo.IsDevmode}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"hash value: {generationInfo.TypesHashValue}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"tags: {generationInfo.Tags}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"------------------------------------------------------------------------------"));
foreach (var item in generationInfo.Types)
{
CreateDataType(codeNamespace, item, generationInfo);
}
//if (NoCpp == false)
// codeNamespace.AddHeaderStatement("void register_enums();");
}
private static void CreateConstructor(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Public;
cc.Parameters.Add(generationInfo.ReaderNamespace, "idataset&", "dataSet");
cc.Parameters.Add(new CodeTypeReference(typeof(bool)), "verifyRevision");
foreach (var item in generationInfo.GetTables(true))
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), item.Name);
cc.Statements.AddAssign(field, new CodePrimitiveExpression(null));
}
var methodInvokeExp = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Load", new CodeVariableReferenceExpression("dataSet"), new CodeVariableReferenceExpression("verifyRevision"));
cc.Statements.Add(methodInvokeExp);
classType.Members.Add(cc);
}
public static void Create(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo)
{
codeNamespace.Comments.Add(new CodeCommentStatement($"------------------------------------------------------------------------------"));
codeNamespace.Comments.Add(new CodeCommentStatement($"dataBase: {generationInfo.DataBaseName}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"revision: {generationInfo.Revision}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"requested revision: {generationInfo.RequestedRevision}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"devmode: {generationInfo.IsDevmode}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"hash value: {generationInfo.TablesHashValue}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"tags: {generationInfo.Tags}"));
codeNamespace.Comments.Add(new CodeCommentStatement($"------------------------------------------------------------------------------"));
foreach (var item in generationInfo.GetTables())
{
CremaTableClassCreator.Create(codeNamespace, item, generationInfo);
}
var classType = new CodeTypeDeclaration();
codeNamespace.Types.Add(classType);
classType.Name = generationInfo.ClassName;
classType.IsClass = true;
classType.BaseTypes.Add(generationInfo.BaseNamespace, "CremaData");
CreateNameField(classType, generationInfo);
CreateRevisionField(classType, generationInfo);
CreateTypesHashValueField(classType, generationInfo);
CreateTablesHashValueField(classType, generationInfo);
CreateTagsField(classType, generationInfo);
CreateNameMethod(classType, generationInfo);
CreateRevisionMethod(classType, generationInfo);
CreateTypesHashValueMethod(classType, generationInfo);
CreateTablesHashValueMethod(classType, generationInfo);
CreateTagsMethod(classType, generationInfo);
CreateFieldsTable(classType, generationInfo);
CreateConstructor(classType, generationInfo);
CreateConstructorFromFile(classType, generationInfo);
CreateLoadFromFile(classType, generationInfo);
CreateLoad(classType, generationInfo);
CreateDestructor(classType, generationInfo);
}
private static void CreateColumnProperties(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in tableInfo.Columns)
{
var cmp = new CodeMemberProperty();
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmp.Name = item.Name;
cmp.Type = item.GetPropertyType();
if (generationInfo.NoComment == false)
{
cmp.Comments.AddSummary(item.Comment);
}
if (generationInfo.NoChanges == false)
{
cmp.Comments.Add(CremaSchema.Creator, item.CreationInfo.ID);
cmp.Comments.Add(CremaSchema.CreatedDateTime, item.CreationInfo.DateTime);
cmp.Comments.Add(CremaSchema.Modifier, item.ModificationInfo.ID);
cmp.Comments.Add(CremaSchema.ModifiedDateTime, item.ModificationInfo.DateTime);
}
cmp.HasGet = true;
cmp.HasSet = false;
// return field;
{
var field = item.GetFieldExpression();
cmp.GetStatements.AddMethodReturn(field);
}
classType.Members.Add(cmp);
}
}
private static void CreateColumnFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in tableInfo.Columns)
{
var cmf = new CodeMemberField();
cmf.Attributes = MemberAttributes.Public;
cmf.Name = item.Name;
cmf.Type = item.GetCodeType(CodeType.None);
cmf.InitExpression = item.GetInitExpression();
if (generationInfo.NoComment == false)
{
cmf.Comments.AddSummary(item.Comment);
}
if (generationInfo.NoChanges == false)
{
cmf.Comments.Add(CremaSchema.Creator, item.CreationInfo.ID);
cmf.Comments.Add(CremaSchema.CreatedDateTime, item.CreationInfo.DateTime);
cmf.Comments.Add(CremaSchema.Modifier, item.ModificationInfo.ID);
cmf.Comments.Add(CremaSchema.ModifiedDateTime, item.ModificationInfo.DateTime);
}
classType.Members.Add(cmf);
}
}
private static CodeStatement CreateCompareTypeStatement(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var table = new CodeVariableReferenceExpression("table");
var version = new CodeMethodInvokeExpression(table, "hash_value");
var state = new CodeConditionStatement();
state.Condition = new CodeBinaryOperatorExpression(version, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(tableInfo.HashValue));
var message = string.Format("{0} 테이블과 데이터의 형식이 맞지 않습니다.", tableInfo.Name);
var exception = new CodeObjectCreateExpression("std::exception", new CodePrimitiveExpression(message));
state.TrueStatements.Add(new CodeThrowExceptionStatement(exception));
return(state);
}
private static void CreateDataTypeRegisterMethod(CodeNamespace codeNamespace, TypeInfo dataTypeInfo, CodeGenerationInfo generationInfo)
{
using (IndentedTextWriter tw = new IndentedTextWriter(new StringWriter()))
{
tw.WriteLine("void register_{0}()", dataTypeInfo.Name);
tw.WriteLine("{");
tw.Indent++;
tw.WriteLine("static ntreev::crema::enum_info enumData({0});", dataTypeInfo.IsFlag.ToString().ToLower());
tw.WriteLine("if(ntreev::crema::enum_util::contains(typeid({0})) == true)", dataTypeInfo.Name);
tw.Indent++;
tw.WriteLine("return;");
tw.Indent--;
foreach (var item in dataTypeInfo.Members)
{
tw.WriteLine("enumData.add(\"{0}_{1}\", {0}_{1});", dataTypeInfo.Name, item.Name);
}
tw.WriteLine("ntreev::crema::enum_util::add(typeid({0}), &enumData);", dataTypeInfo.Name);
tw.Indent--;
tw.Write("}");
tw.Flush();
codeNamespace.AddCppStatement(tw.InnerWriter.ToString());
}
}
private static void CreateCreateRowInstanceMethod(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Family | MemberAttributes.Override;
cmm.Name = "CreateRow";
cmm.ReturnType = new CodeTypeReference(typeof(object));
cmm.Parameters.Add(generationInfo.ReaderNamespace, "irow&", "row");
cmm.Parameters.Add(typeof(object), "table");
// statement
{
var row = new CodeVariableReferenceExpression("row");
var tablePtr = new CodeVariableReferenceExpression("table");
var table = new CodeCastExpression(tableInfo.GetCodeType(CodeType.Pointer), tablePtr);
var instance = new CodeObjectCreateExpression(tableInfo.GetRowCodeType(CodeType.None), row, table);
cmm.Statements.AddMethodReturn(instance);
}
classType.Members.Add(cmm);
}
private static void CreateFindMethod(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Name = "Find";
cmm.ReturnType = tableInfo.GetRowCodeType(CodeType.Pointer | CodeType.Const);
cmm.Parameters.Add(tableInfo.Columns.Where(item => item.IsKey));
cmm.IsConst(true);
// invoke base.FindRow
{
var query = from item in tableInfo.Columns
where item.IsKey
select new CodeVariableReferenceExpression(item.Name);
var invokeFindRow = new CodeMethodInvokeExpression(thisRef, "FindRow", query.ToArray());
cmm.Statements.AddMethodReturn(invokeFindRow);
}
classType.Members.Add(cmm);
}
private static void CreateConstructorFromTable(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Public;
cc.Name = tableInfo.TableName;
cc.Parameters.Add(generationInfo.ReaderNamespace, "itable&", "table");
//cc.BaseConstructorArgs.Add("table");
//cc.AddConstructorStatement(string.Format("{0}(table)", CodeGenerationInfo.CremaTableName));
// verify hashValue
{
var css = CreateCompareTypeStatement(classType, tableInfo, generationInfo);
var tst = CremaDataClassCreator.CreateTryCatchStatement(classType, css, generationInfo);
cc.Statements.Add(css);
}
{
var table = new CodeVariableReferenceExpression("table");
var dataSet = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(table, "dataset"));
var tables = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(dataSet, "tables"));
foreach (var item in generationInfo.GetChilds(tableInfo))
{
var tableName = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(table, "name"));
var childName = new CodeBinaryOperatorExpression(tableName, CodeBinaryOperatorType.Add, new CodePrimitiveExpression("." + item.TableName));
var childTable = new CodeIndexerExpression(tables, childName);
var childField = new CodeFieldReferenceExpression(thisRef, item.TableName);
var instance = new CodeObjectCreateExpression(item.GetCodeType(CodeType.None), childTable);
cc.Statements.AddAssign(childField, instance);
//cc.AddConstructorStatement(string.Format("{0}(table.dataset().tables()[\"{1}\"])", item.GetFieldName(), item.GetUniqueName()));
}
}
{
var table = new CodeVariableReferenceExpression("table");
var readFromFile = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "ReadFromTable");
var methodInvoke = new CodeMethodInvokeExpression(readFromFile, table);
cc.Statements.Add(methodInvoke);
}
// SetRelations
{
var table = new CodeVariableReferenceExpression("table");
foreach (var item in generationInfo.GetChilds(tableInfo))
{
var setRelations = new CodeMethodReferenceExpression(thisRef, "SetRelations");
var field = new CodeFieldPointerExpression(thisRef, item.TableName);
var rows = new CodePropertyReferenceExpression(field, "Rows");
var codeTypeRef = new CodeTypeReferenceExpression(tableInfo.GetRowCodeType(CodeType.None));
var setChildAction = new CodePropertyReferenceExpression(null, tableInfo.TableName + "Set" + item.TableName);
var tableName = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(table, "name"));
var childName = new CodeBinaryOperatorExpression(tableName, CodeBinaryOperatorType.Add, new CodePrimitiveExpression("." + item.TableName));
var setRelationsInvoke = new CodeMethodInvokeExpression(setRelations, childName, rows, setChildAction);
cc.Statements.Add(setRelationsInvoke);
}
}
classType.Members.Add(cc);
}
private static void CreateConstructor(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Public;
classType.Members.Add(cc);
}
private static void CreateSetChildsMethod(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetChilds(tableInfo))
{
var cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.FamilyAndAssembly | MemberAttributes.Static;
cmm.Name = tableInfo.TableName + "Set" + item.TableName;
cmm.Parameters.Add(tableInfo.GetRowCodeType(CodeType.Pointer), "target");
var arrayType = new CodeTypeReference(item.GetRowCodeType(CodeType.Pointer), 1);
arrayType.SetCodeType(CodeType.Const | CodeType.Reference);
var childNameType = new CodeTypeReference(typeof(string));
childNameType.SetCodeType(CodeType.Const | CodeType.Reference);
cmm.Parameters.Add(childNameType, "childName");
cmm.Parameters.Add(arrayType, "childs");
{
var methodRefExp = new CodeMethodReferenceExpression(null, "SetParent");
//methodRefExp.TypeArguments.Add(tableInfo.GetRowCodeType());
//methodRefExp.TypeArguments.Add(item.GetRowCodeType());
var methodInvokeExp = new CodeMethodInvokeExpression(methodRefExp, new CodeVariableReferenceExpression("target"), new CodeVariableReferenceExpression("childs"));
cmm.Statements.AddExpression(methodInvokeExp);
}
{
var target = new CodeVariablePointerExpression("target");
var childName = new CodeVariablePointerExpression("childName");
var childs = new CodeVariableReferenceExpression("childs");
var targetField = item.GetFieldExpression(target);
var targetInstance = new CodeObjectCreateExpression(item.GetCodeType(CodeType.None), childName, childs);
cmm.Statements.AddAssign(targetField, targetInstance);
}
classType.Members.Add(cmm);
}
}
private static void CreateStaticChildEmptyFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetChilds(tableInfo))
{
var cmf = new CodeMemberField();
cmf.Attributes = MemberAttributes.Private | MemberAttributes.Static;
cmf.Name = item.GetFieldName() + "Empty";
cmf.Type = item.GetCodeType(CodeType.None);
//cmf.InitExpression = new CodeObjectCreateExpression(item.GetCodeType(CodeType.None));
classType.Members.Add(cmf);
}
}
private static void CreateDataTypeRegisterMethods(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.Types)
{
CreateDataTypeRegisterMethod(codeNamespace, item, generationInfo);
}
using (var tw = new IndentedTextWriter(new StringWriter()))
{
tw.WriteLine("void register_enums()");
tw.WriteLine("{");
tw.Indent++;
foreach (var item in generationInfo.Types)
{
tw.WriteLine("register_{0}();", item.Name);
}
tw.Indent--;
tw.Write("}");
tw.Flush();
codeNamespace.AddCppStatement(tw.InnerWriter.ToString());
}
}
private static void CreateConstructor(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Public;
cc.Parameters.Add(generationInfo.ReaderNamespace, "irow&", "row");
cc.Parameters.Add(tableInfo.GetCodeType(CodeType.Pointer), "table");
cc.AddConstructorStatement(string.Format("{0}(row)", CodeGenerationInfo.CremaRowName));
//cc.AddConstructorStatement("Table(*table)");
//foreach (var item in tableInfo.Columns)
//{
// CodeBinaryOperatorExpression cbor = new CodeBinaryOperatorExpression();
// cbor.Left = new CodeVariableReferenceExpression("propertyName");
// cbor.Operator = CodeBinaryOperatorType.ValueEquality;
// cbor.Right = new CodePrimitiveExpression(item.Name);
// CodeConditionStatement ccs = new CodeConditionStatement(item.GetHasValueMethodExpression());
// CodeAssignStatement cas = new CodeAssignStatement();
// cas.Left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), item.Name);
// cas.Right = item.GetGetValueMethodExpression();
// ccs.TrueStatements.Add(cas);
// cc.Statements.Add(ccs);
//}
//var query = from item in tableInfo.Columns
// where item.IsKey
// select item;
////method.AddStatement(string.Format("cremarow::initialize(row, iniutil::generate_hash({0}, {1}));", query.Count(), string.Join(", ", query)));
//CodeMethodInvokeExpression generate_hashExp = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("iniutil"), "generate_hash");
//foreach (var item in query)
//{
// CodeFieldReferenceExpression fieldExp = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), item.Name);
// if (item.IsCustomType() == false)
// generate_hashExp.Parameters.Add(fieldExp);
// else
// generate_hashExp.Parameters.Add(new CodeCastExpression(new CodeTypeReference(typeof(int)), fieldExp));
//}
// assign table
{
var tableField = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Table");
var tableVar = new CodeVariableReferenceExpression("table");
cc.Statements.AddAssign(tableField, tableVar);
}
// assign fields
{
int index = 0;
foreach (var item in tableInfo.Columns)
{
var cas = new CodeAssignStatement();
cas.Left = item.GetFieldExpression();
cas.Right = item.GetGetValueMethodExpression(index, false);
if (item.IsKey == false)
{
var ccs = new CodeConditionStatement(item.GetHasValueMethodExpression(index, false));
ccs.TrueStatements.Add(cas);
cc.Statements.Add(ccs);
}
else
{
cc.Statements.Add(cas);
}
index++;
}
}
//CodeMethodInvokeExpression methodExp = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("cremarow"), "initialize");
//methodExp.Parameters.Add(new CodeVariableReferenceExpression("row"));
//methodExp.Parameters.Add(generate_hashExp);
//cc.Statements.Add(new CodeExpressionStatement(methodExp));
//var query = from item in columns
// where item.IsKey
// select item.Name;
//method.AddStatement(string.Format("cremarow::initialize(row, iniutil::generate_hash({0}, {1}));", query.Count(), string.Join(", ", query)));
foreach (var item in generationInfo.GetChilds(tableInfo))
{
// check null and return defaultField
{
var state = new CodeConditionStatement();
var condition = new CodeBinaryOperatorExpression(item.GetFieldExpression(), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
state.Condition = condition;
var codeTypeRef = new CodeTypeReferenceExpression(tableInfo.GetRowCodeType(CodeType.None));
var staticField = new CodeFieldReferenceExpression(codeTypeRef, item.GetFieldName() + "Empty");
state.TrueStatements.AddAssignReference(item.GetFieldExpression(), staticField);
cc.Statements.Add(state);
}
// return field;
//{
// var fieldExp = item.GetFieldExpression();
// cmp.GetStatements.AddMethodReturn(fieldExp, CodeType.None);
//}
//classType.Members.Add(cmp);
}
// invoke SetKey method
{
var methodRefExp = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "SetKey");
var methodInvokeExp = new CodeMethodInvokeExpression(methodRefExp);
foreach (var item in tableInfo.Columns)
{
if (item.IsKey == true)
{
methodInvokeExp.Parameters.Add(item.GetFieldExpression());
}
}
cc.Statements.Add(methodInvokeExp);
}
classType.Members.Add(cc);
}
private static void CreateDataType(CodeNamespace codeNamespace, TypeInfo dataTypeInfo, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration(dataTypeInfo.Name);
classType.Attributes = MemberAttributes.Public;
classType.IsEnum = true;
if (dataTypeInfo.IsFlag == true)
{
CodeAttributeDeclaration cad = new CodeAttributeDeclaration(new CodeTypeReference(typeof(FlagsAttribute)));
classType.CustomAttributes.Add(cad);
}
if (generationInfo.NoComment == false)
{
classType.Comments.AddSummary(dataTypeInfo.Comment);
}
if (generationInfo.NoChanges == false)
{
classType.Comments.Add(CremaSchema.Creator, dataTypeInfo.CreationInfo.ID);
classType.Comments.Add(CremaSchema.CreatedDateTime, dataTypeInfo.CreationInfo.DateTime);
classType.Comments.Add(CremaSchema.Modifier, dataTypeInfo.ModificationInfo.ID);
classType.Comments.Add(CremaSchema.ModifiedDateTime, dataTypeInfo.ModificationInfo.DateTime);
}
foreach (var item in dataTypeInfo.Members)
{
CreateDataMember(classType, item, generationInfo);
}
//CreateEnumRegisterMethod(enum1, isFlag);
codeNamespace.Types.Add(classType);
}
