public IDictionary <string, string> Generate(CodeGenerationInfo generationInfo) { var codes = new Dictionary <string, string>(); var codeDomProvider = new CodeDom.NativeCCodeProvider(); var options = new CodeGeneratorOptions { BlankLinesBetweenMembers = generationInfo.BlankLinesBetweenMembers, BracingStyle = "C", ElseOnClosing = false, 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); SplitCode(cremaTypes, $"{generationInfo.Prefix}types{generationInfo.Postfix}.h", out var cremaTypesHeader, out var cremaTypesCpp); SplitCode(cremaTables, $"{generationInfo.Prefix}tables{generationInfo.Postfix}.h", out var cremaTablesHeader, out var 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 void CreateLoadFromFile(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cc = new CodeMemberMethod { Attributes = MemberAttributes.Public | MemberAttributes.Final, 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 GenerateReaderCpp(CodeGenerationInfo generationInfo) { var assembly = System.Reflection.Assembly.GetExecutingAssembly(); var resourceName = string.Join(".", assembly.GetName().Name, "code", "crema_reader.cpp"); var code = this.GetResourceString(resourceName); return(this.ChangeReadNamespace(code, generationInfo)); }
private static void CreateTagsField(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cmf = new CodeMemberField { Attributes = MemberAttributes.Private, Name = "_tags", Type = new CodeTypeReference(typeof(string)) }; classType.Members.Add(cmf); }
private IDictionary <string, string> GenerateBases(CodeGenerationInfo generationInfo) { var codes = new Dictionary <string, string>(); var assembly = System.Reflection.Assembly.GetExecutingAssembly(); codes.Add("crema_base.h", this.GenerateBaseHeader(generationInfo)); codes.Add("crema_base.cpp", this.GenerateBaseCpp(generationInfo)); codes.Add("crema_reader.h", this.GenerateReaderHeader(generationInfo)); codes.Add("crema_reader.cpp", this.GenerateReaderCpp(generationInfo)); return(codes); }
private static void CreateFieldsTable(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.GetTables(true)) { var cmf = new CodeMemberField { Attributes = MemberAttributes.Public, Name = item.Name, Type = item.GetCodeType(CodeType.Pointer | CodeType.Const) }; classType.Members.Add(cmf); } }
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 CreateTagsMethod(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cmm = new CodeMemberMethod { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = "tags", ReturnType = new CodeTypeReference(typeof(string)) }; cmm.Statements.AddMethodReturn(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "_tags")); classType.Members.Add(cmm); }
private static void CreateDestructor(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cc = new CodeDestructor { 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 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($"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();"); }
public void Generate(string outputPath, GenerationSet metaData, CodeGenerationSettings settings) { var path = PathUtility.GetFullPath(outputPath); var generationInfo = new CodeGenerationInfo(metaData, settings) { RelativePath = string.Empty, }; if (settings.BasePath != string.Empty) { var relativePath = UriUtility.MakeRelativeOfDirectory(path, DirectoryUtility.GetAbsolutePath(path, settings.BasePath)); generationInfo.RelativePath = relativePath + "/"; } { var codes = this.Generate(generationInfo); var dirInfo = new DirectoryInfo(path); 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 var 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(path, 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); } } }
private static void CreateConstructor(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cc = new CodeConstructor { 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($"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 CreateStaticChildEmptyFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.GetChilds(tableInfo)) { var cmf = new CodeMemberField { Attributes = MemberAttributes.Private | MemberAttributes.Static, Name = item.GetFieldName() + "Empty", Type = item.GetCodeType(CodeType.None) }; //cmf.InitExpression = new CodeObjectCreateExpression(item.GetCodeType(CodeType.None)); classType.Members.Add(cmf); } }
private static void CreateSetChildsMethod(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { foreach (var item in generationInfo.GetChilds(tableInfo)) { var cmm = new CodeMemberMethod { Attributes = MemberAttributes.Public | MemberAttributes.Static, 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(tableInfo.GetRowCodeTypeExpression(CodeType.None), "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 CreateColumnFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { foreach (var item in tableInfo.Columns) { var cmf = new CodeMemberField { Attributes = MemberAttributes.Public, Name = item.Name, Type = item.GetCodeType(CodeType.None), 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); } }
public static CodeStatement CreateTryCatchStatement(CodeTypeDeclaration classType, CodeStatement statement, CodeGenerationInfo generationInfo) { var tryStatement = new CodeTryCatchFinallyStatement(); tryStatement.TryStatements.Add(statement); var catchClause = new CodeCatchClause("e", new CodeTypeReference("std::exception&")); var methodRefExp = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression($"{generationInfo.BaseNamespace}.CremaData"), "InvokeErrorOccured"); var methodInvokeExp = new CodeMethodInvokeExpression(methodRefExp, new CodeVariableReferenceExpression("e")); var conditionStatement = new CodeConditionStatement { Condition = new CodeBinaryOperatorExpression(methodInvokeExp, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(false)) }; conditionStatement.TrueStatements.Add(new CodeThrowExceptionStatement(new CodeVariableReferenceExpression("e"))); catchClause.Statements.Add(conditionStatement); tryStatement.CatchClauses.Add(catchClause); return(tryStatement); }
private static CodeStatement CreateCompareRevisionStatement(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var ccs = new CodeConditionStatement(); var left1 = new CodeVariableReferenceExpression("verifyRevision"); var right1 = new CodePrimitiveExpression(true); var left = new CodeBinaryOperatorExpression(left1, CodeBinaryOperatorType.IdentityEquality, right1); var left2 = new CodeCastExpression(typeof(string), new CodePrimitiveExpression(generationInfo.Revision)); var right2 = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataSet"), "revision()"); var right = new CodeBinaryOperatorExpression(left2, CodeBinaryOperatorType.IdentityInequality, right2); ccs.Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.BooleanAnd, right); var message = string.Format("데이터의 리비전 코드 리비전({0})과 다릅니다.", generationInfo.Revision); var exception = new CodeMethodInvokeExpression(null, "std::logic_error", new CodePrimitiveExpression(message)); ccs.TrueStatements.Add(new CodeThrowExceptionStatement(exception)); return(ccs); }
private static CodeStatement CreateCompareTablesHashValueStatement(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var ccs = new CodeConditionStatement(); var left = new CodePrimitiveExpression(generationInfo.TablesHashValue); var right = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataSet"), "tables_hash_value()"); ccs.Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityInequality, right); var message = "테이블 해시값이 잘못되었습니다."; var exception = new CodeMethodInvokeExpression(null, "std::logic_error", new CodePrimitiveExpression(message)); ccs.TrueStatements.Add(new CodeThrowExceptionStatement(exception)); return(ccs); }
private static void CreateDataType(CodeNamespace codeNamespace, TypeInfo dataTypeInfo, CodeGenerationInfo generationInfo) { var classType = new CodeTypeDeclaration(dataTypeInfo.Name) { Attributes = MemberAttributes.Public, IsEnum = true }; if (dataTypeInfo.IsFlag == true) { var 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); }
private static void CreateDataMember(CodeTypeDeclaration classType, TypeMemberInfo typeMemberInfo, CodeGenerationInfo generationInfo) { var cmm = new CodeMemberField { Name = typeMemberInfo.Name, InitExpression = new CodeSnippetExpression(generationInfo.EnumFomrat(typeMemberInfo.Value)) }; if (generationInfo.NoComment == false) { cmm.Comments.AddSummary(typeMemberInfo.Comment); } if (generationInfo.NoChanges == false) { cmm.Comments.Add(CremaSchema.Creator, typeMemberInfo.CreationInfo.ID); cmm.Comments.Add(CremaSchema.CreatedDateTime, typeMemberInfo.CreationInfo.DateTime); cmm.Comments.Add(CremaSchema.Modifier, typeMemberInfo.ModificationInfo.ID); cmm.Comments.Add(CremaSchema.ModifiedDateTime, typeMemberInfo.ModificationInfo.DateTime); } classType.Members.Add(cmm); }
private string GenerateTables(CodeDomProvider codeDomProvider, CodeGeneratorOptions options, CodeGenerationInfo generationInfo) { var sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { var codeGenerator = codeDomProvider.CreateGenerator(sw); var compileUnit = new CodeCompileUnit(); compileUnit.AddCustomInclude($"{generationInfo.RelativePath}crema_reader"); compileUnit.AddCustomInclude($"{generationInfo.Prefix}types{generationInfo.Postfix}"); compileUnit.AddCustomInclude($"{generationInfo.RelativePath}crema_base"); var codeNamespace = new CodeNamespace(generationInfo.Namespace); codeNamespace.Imports.Add(new CodeNamespaceImport(generationInfo.ReaderNamespace)); CremaDataClassCreator.Create(codeNamespace, generationInfo); compileUnit.Namespaces.Add(codeNamespace); codeGenerator.GenerateCodeFromCompileUnit(compileUnit, sw, options); } return(sb.ToString()); }
private static void CreateLoad(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var cc = new CodeMemberMethod { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = "Load" }; cc.Parameters.Add(generationInfo.ReaderNamespace, "idataset&", "dataSet"); cc.Parameters.Add(new CodeTypeReference(typeof(bool)), "verifyRevision"); var dataSet = new CodeVariableReferenceExpression("dataSet"); { var ccs = CreateCompareDataBaseStatement(classType, generationInfo); var tst = CreateTryCatchStatement(classType, ccs, generationInfo); cc.Statements.Add(tst); } { var ccs = CreateCompareRevisionStatement(classType, generationInfo); var tst = CreateTryCatchStatement(classType, ccs, generationInfo); cc.Statements.Add(tst); } { var ccs = CreateCompareTypesHashValueStatement(classType, generationInfo); var tst = CreateTryCatchStatement(classType, ccs, generationInfo); cc.Statements.Add(tst); } { var ccs = CreateCompareTablesHashValueStatement(classType, generationInfo); var tst = CreateTryCatchStatement(classType, ccs, generationInfo); cc.Statements.Add(tst); } { var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_name"); var property = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(dataSet, "name")); cc.Statements.AddAssign(field, property); } { var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_revision"); var property = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(dataSet, "revision")); cc.Statements.AddAssign(field, property); } { var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_typesHashValue"); var property = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(dataSet, "types_hash_value")); cc.Statements.AddAssign(field, property); } { var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_tablesHashValue"); var property = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(dataSet, "tables_hash_value")); cc.Statements.AddAssign(field, property); } { var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_tags"); var property = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(dataSet, "tags")); cc.Statements.AddAssign(field, property); } foreach (var item in generationInfo.GetTables(true)) { var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), item.Name); var operatorExp = new CodeBinaryOperatorExpression(field, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); var ccs = new CodeConditionStatement(operatorExp); var delete = new CodeObjectDeleteExpression(field); ccs.TrueStatements.Add(delete); cc.Statements.Add(ccs); var tableName = new CodePrimitiveExpression(item.Name); var tablesProp = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(dataSet, "tables")); var table = new CodeIndexerExpression(tablesProp, tableName); //var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), item.Name); var instance = new CodeObjectCreateExpression(item.GetCodeType(generationInfo.Namespace, CodeType.None), table); cc.Statements.AddAssign(field, instance); } classType.Members.Add(cc); }
private string GenerateTypes(CodeDomProvider codeDomProvider, CodeGeneratorOptions options, CodeGenerationInfo generationInfo) { var sb = new StringBuilder(); using (var sw = new StringWriter(sb)) { var codeGenerator = codeDomProvider.CreateGenerator(sw); var compileUnit = new CodeCompileUnit(); var codeNamespace = new CodeNamespace(generationInfo.Namespace); codeNamespace.Imports.Add(new CodeNamespaceImport(generationInfo.ReaderNamespace)); CremaTypeEnumCreator.Create(codeNamespace, generationInfo); compileUnit.Namespaces.Add(codeNamespace); codeGenerator.GenerateCodeFromCompileUnit(compileUnit, sw, options); } return(sb.ToString()); }
private static void CreateConstructor(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo) { var cc = new CodeConstructor { 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 { Left = item.GetFieldExpression(), 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 nullCompare = new CodeBinaryOperatorExpression(item.GetFieldExpression(), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null)); var condition = new CodeBinaryOperatorExpression(nullCompare, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true)); 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) { if (item.DataType == typeof(string).GetTypeName() == true) { methodInvokeExp.Parameters.Add(new CodeMethodInvokeExpression(item.GetFieldExpression(), "c_str")); } else { methodInvokeExp.Parameters.Add(item.GetFieldExpression()); } } } cc.Statements.Add(methodInvokeExp); } classType.Members.Add(cc); }
private static CodeStatement CreateCompareDataBaseStatement(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo) { var ccs = new CodeConditionStatement(); var left = new CodePrimitiveExpression(generationInfo.DataBaseName); var right = new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("dataSet"), "name()"); ccs.Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityInequality, right); var message = string.Format("데이터의 이름이 코드 이름({0})과 다릅니다.", generationInfo.DataBaseName); var exception = new CodeMethodInvokeExpression(null, "std::logic_error", new CodePrimitiveExpression(message)); ccs.TrueStatements.Add(new CodeThrowExceptionStatement(exception)); return(ccs); }