private static CodeTypeDeclaration CreateCore(TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration();
classType.Attributes = MemberAttributes.Public;
classType.Name = tableInfo.GetClassName();
classType.IsClass = true;
classType.TypeAttributes |= TypeAttributes.Sealed;
classType.BaseTypes.Add("base", "CremaTable", tableInfo.GetRowCodeType());
if (generationInfo.OmitComment == false)
{
classType.Comments.AddSummary(tableInfo.Comment);
}
if (generationInfo.OmitSignatureDate == false)
{
classType.Comments.Add(CremaCodeGenerator.Creator, tableInfo.CreationInfo.ID);
classType.Comments.Add(CremaCodeGenerator.CreatedDateTime, tableInfo.CreationInfo.DateTime);
classType.Comments.Add(CremaCodeGenerator.Modifier, tableInfo.ModificationInfo.ID);
classType.Comments.Add(CremaCodeGenerator.ModifiedDateTime, tableInfo.ModificationInfo.DateTime);
classType.Comments.Add(CremaCodeGenerator.ContentsModifier, tableInfo.ContentsInfo.ID);
classType.Comments.Add(CremaCodeGenerator.ContentsModifiedDateTime, tableInfo.ContentsInfo.DateTime);
}
CreateChildFields(classType, tableInfo, generationInfo);
CreateChildProperties(classType, tableInfo, generationInfo);
CreateCreateFromTableMethod(classType, tableInfo, generationInfo);
CreateCreateFromRowsMethod(classType, tableInfo, generationInfo);
CreateReadFromRowsMethod(classType, tableInfo);
CreateFindMethod(classType, tableInfo, generationInfo);
CreateCreateRowInstanceMethod(classType, tableInfo, generationInfo);
CreateReadFromTableMethod(classType, tableInfo, generationInfo);
return(classType);
}
public static void Create(CodeNamespace codeNamespace, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetTables())
{
Create(codeNamespace, item, generationInfo);
}
}
public void Generate(string outputPath, GenerationSet metaData, CodeGenerationSettings settings)
{
var generationInfo = new CodeGenerationInfo(outputPath, metaData, settings);
if (settings.Options.HasFlag(CodeGenerationOptions.OmitCode) == false)
{
var codes = this.GenerateCodes(generationInfo);
foreach (var item in codes)
{
var codePath = FileUtility.WriteAllText(item.Value, Encoding.UTF8, outputPath, item.Key);
this.PrintResult(codePath);
}
}
if (settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == false)
{
var codes = this.GenerateBaseCodes(generationInfo);
foreach (var item in codes)
{
var codePath = FileUtility.WriteAllText(item.Value, Encoding.UTF8, outputPath, item.Key);
this.PrintResult(codePath);
}
}
}
public void Compile(string outputPath, GenerationSet metaData, CodeGenerationSettings settings, string target)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
var generationInfo = new CodeGenerationInfo(outputPath, metaData, settings);
var codes1 = this.GenerateCodes(generationInfo);
var codes2 = this.GenerateBaseCodes(generationInfo);
var codes3 = codes1.Concat(codes2).ToDictionary(item => item.Key, item => item.Value);
var codes = TypeScriptCompiler.Compile(codes3, target == string.Empty ? "ES5" : target);
if (Directory.Exists(outputPath) == false)
{
Directory.CreateDirectory(outputPath);
}
foreach (var item in codes)
{
string codePath = Path.Combine(outputPath, item.Key);
using (StreamWriter sw = new StreamWriter(codePath, false, Encoding.UTF8))
{
sw.WriteLine(item.Value);
this.PrintResult(codePath);
}
}
}
public static void Create(CodeNamespace codeNamespace, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration();
classType.Attributes = MemberAttributes.Public;
classType.Name = tableInfo.GetRowClassName();
classType.IsClass = true;
classType.TypeAttributes |= TypeAttributes.Sealed;
classType.BaseTypes.Add("base", "CremaRow");
CreateStaticChildEmptyFields(classType, tableInfo, generationInfo);
CreateTableField(classType, tableInfo);
CreateColumnFields(classType, tableInfo, generationInfo);
CreateChildFields(classType, tableInfo, generationInfo);
CreateConstructor(classType, tableInfo, generationInfo);
CreateSetChildsMethod(classType, tableInfo, generationInfo);
CreateColumnProperties(classType, tableInfo, generationInfo);
CreateChildProperties(classType, tableInfo, generationInfo);
CreateTableProperty(classType, tableInfo);
CreateParentProperty(classType, tableInfo);
codeNamespace.Types.Add(classType);
}
private string GenerateReader(CodeGenerationInfo generationInfo)
{
var sb = new StringBuilder();
this.AppendLint(sb, generationInfo);
var text = this.GetResourceString("Reader.crema-reader.ts");
sb.Append(text);
return(sb.ToString());
}
private static void CreateRevisionField(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmf = new CodeMemberField();
cmf.Attributes = MemberAttributes.Private;
cmf.Name = "_revision";
cmf.Type = new CodeTypeReference(typeof(long));
classType.Members.Add(cmf);
}
private static void CreateTagsHashValueField(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 IDictionary <string, string> GenerateBaseCodes(CodeGenerationInfo generationInfo)
{
var codes = new Dictionary <string, string>();
var baseCode = GenerateBase(generationInfo);
var readerCode = GenerateReader(generationInfo);
codes.Add($"{generationInfo.RelativePath}{generationInfo.Namespace}-base.ts", baseCode);
codes.Add($"{generationInfo.RelativePath}{generationInfo.Namespace}-reader.ts", readerCode);
return(codes);
}
private string GenerateBase(CodeGenerationInfo generationInfo)
{
var sb = new StringBuilder();
this.AppendLint(sb, generationInfo);
var text = this.GetResourceString("Reader.crema-base.ts");
var text2 = text.Replace("./crema-reader", string.Format("./{0}-reader", generationInfo.Namespace));
sb.Append(text2);
return(sb.ToString());
}
private static void CreateTagsProperty(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberProperty();
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Name = "tags";
cmm.HasGet = true;
cmm.Type = new CodeTypeReference(typeof(string));
cmm.GetStatements.AddMethodReturn(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "_tags"));
classType.Members.Add(cmm);
}
private static void CreateTableFields(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetTables(true))
{
var cmf = new CodeMemberField();
cmf.Attributes = MemberAttributes.Private;
cmf.Name = item.GetFieldName();
cmf.Type = item.GetCodeType();
classType.Members.Add(cmf);
}
}
private void AppendLint(StringBuilder sb, CodeGenerationInfo generationInfo)
{
if (generationInfo.TSLintDisable != null)
{
if (generationInfo.TSLintDisable == string.Empty)
{
sb.AppendLine($"// tslint:disable");
}
else
{
sb.AppendLine($"// tslint:disable: {generationInfo.TSLintDisable}");
}
sb.AppendLine();
}
}
public static void CreateTypes(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)
{
CreateType(codeNamespace, item, generationInfo);
}
}
private static void CreateTableProperties(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetTables(true))
{
var cmp = new CodeMemberProperty();
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmp.Name = item.Name;
cmp.Type = item.GetCodeType();
cmp.HasGet = true;
cmp.HasSet = false;
cmp.Comments.AddSummary(item.Comment);
cmp.GetStatements.AddMethodReturn(item.GetFieldExpression());
classType.Members.Add(cmp);
}
}
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, 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();
classType.Attributes = MemberAttributes.Public;
classType.Name = generationInfo.ClassName;
classType.IsClass = true;
classType.TypeAttributes |= TypeAttributes.Sealed;
classType.BaseTypes.Add("base", "CremaData");
CreateNameField(classType, generationInfo);
CreateRevisionField(classType, generationInfo);
CreateTypesHashValueField(classType, generationInfo);
CreateTablesHashValueField(classType, generationInfo);
CreateTagsHashValueField(classType, generationInfo);
CreateNameProperty(classType, generationInfo);
CreateRevisionProperty(classType, generationInfo);
CreateTypesHashValueProperty(classType, generationInfo);
CreateTablesHashValueProperty(classType, generationInfo);
CreateTagsProperty(classType, generationInfo);
CreateTableFields(classType, generationInfo);
CreateCreateFromDataSetMethod(classType, generationInfo);
CreateCreateFromFileMethod(classType, generationInfo);
CreateTableProperties(classType, generationInfo);
CreateReadFromDataSetMethod(classType, generationInfo);
CreateReadFromFileMethod(classType, generationInfo);
codeNamespace.Types.Add(classType);
}
private static void CreateReadFromFileMethod(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Public;
cmm.Name = "readFromFile";
cmm.Parameters.Add(typeof(string), "filename");
cmm.Parameters.Add(typeof(bool), "verifyRevision");
var filename = new CodeVariableReferenceExpression("filename");
var verifyRevision = new CodeVariableReferenceExpression("verifyRevision");
var cremaReader = new CodeTypeReferenceExpression(Utility.GenerateCodeType("reader", "CremaReader"));
var readFromFile = new CodeMethodInvokeExpression(cremaReader, "readFromFile", filename);
var readFromDataSet = new CodeMethodInvokeExpression(thisRef, "readFromDataSet", readFromFile, verifyRevision);
cmm.Statements.Add(readFromDataSet);
classType.Members.Add(cmm);
}
private IDictionary <string, string> GenerateCodes(CodeGenerationInfo generationInfo)
{
var codes = new Dictionary <string, string>();
var codeDomProvider = new CodeDom.TypeScriptCodeProvider();
var options = new CodeGeneratorOptions()
{
BlankLinesBetweenMembers = true,
};
var cremaTypes = GenerateTypes(codeDomProvider, options, generationInfo);
var cremaTables = GenerateTables(codeDomProvider, options, generationInfo);
var cremaDecl = GenerateDeclaration(codeDomProvider, options, generationInfo);
codes.Add($"{generationInfo.Namespace}-{generationInfo.Prefix}types{generationInfo.Postfix}.ts", cremaTypes);
codes.Add($"{generationInfo.Namespace}-{generationInfo.Prefix}tables{generationInfo.Postfix}.ts", cremaTables);
if (generationInfo.OmitDeclaration == false)
{
codes.Add($"{generationInfo.Namespace}.d.ts", cremaDecl);
}
return(codes);
}
private static void CreateConstructor(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var cc = new CodeConstructor();
cc.Attributes = MemberAttributes.Public;
cc.Parameters.Add("reader", "IRow", "row");
cc.Parameters.Add(tableInfo.GetCodeType(), "table");
cc.BaseConstructorArgs.AddVariableReference("row");
// assign table field
{
var tableField = tableInfo.GetFieldExpression();
var table = new CodeVariableReferenceExpression("table");
cc.Statements.AddAssign(tableField, table);
}
// assign column fields
{
var 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);
var tst = CremaDataClassCreator.CreateTryCatchStatement(classType, ccs, false);
cc.Statements.Add(tst);
}
else
{
cc.Statements.Add(cas);
}
index++;
}
}
// invoke setKey
{
var setKey = new CodeMethodReferenceExpression(thisRef, "setKey");
var invokeSetKey = new CodeMethodInvokeExpression(setKey);
foreach (var item in tableInfo.Columns)
{
if (item.IsKey == true)
{
invokeSetKey.Parameters.Add(item.GetFieldExpression());
}
}
cc.Statements.Add(invokeSetKey);
}
classType.Members.Add(cc);
}
private static void CreateChildProperties(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetChilds(tableInfo))
{
var cmp = new CodeMemberProperty();
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmp.Name = item.GetPropertyName();
cmp.Type = item.GetCodeType();
cmp.HasGet = true;
cmp.HasSet = false;
// check null and return defaultField
{
var state = new CodeConditionStatement();
var condition = new CodeBinaryOperatorExpression(item.GetFieldExpression(), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(null));
state.Condition = condition;
var staticField = new CodeFieldReferenceExpression(tableInfo.GetRowCodeTypeExpression(), item.GetFieldName() + "Empty");
state.TrueStatements.AddMethodReturn(staticField);
cmp.GetStatements.Add(state);
}
// return field;
{
var fieldExp = item.GetFieldExpression();
cmp.GetStatements.AddMethodReturn(fieldExp);
}
classType.Members.Add(cmp);
}
}
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.GetCodeType();
if (generationInfo.OmitComment == false)
{
cmp.Comments.AddSummary(item.Comment);
}
if (generationInfo.OmitSignatureDate == false)
{
cmp.Comments.Add(CremaCodeGenerator.Creator, item.CreationInfo.ID);
cmp.Comments.Add(CremaCodeGenerator.CreatedDateTime, item.CreationInfo.DateTime);
cmp.Comments.Add(CremaCodeGenerator.Modifier, item.ModificationInfo.ID);
cmp.Comments.Add(CremaCodeGenerator.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 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();
cmf.InitExpression = new CodeObjectCreateExpression(item.GetCodeType());
classType.Members.Add(cmf);
}
}
private static void CreateColumnFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in tableInfo.Columns)
{
var cmf = new CodeMemberField();
cmf.Attributes = MemberAttributes.Private;
cmf.Name = item.GetFieldName();
cmf.Type = item.GetCodeType();
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();
cmm.Attributes = MemberAttributes.FamilyAndAssembly | MemberAttributes.Static;
cmm.Name = "Set" + item.TableName;
cmm.Parameters.Add(tableInfo.GetRowCodeType(), "target");
cmm.Parameters.Add(typeof(string), "childName");
cmm.Parameters.Add(item.GetRowCodeType(), 1, "childs");
// invoke setParent
{
var target = new CodeVariableReferenceExpression("target");
var childs = new CodeVariableReferenceExpression("childs");
var setParent = new CodeMethodReferenceExpression(tableInfo.GetRowCodeTypeExpression(), "setParent");
setParent.TypeArguments.Add(tableInfo.GetRowCodeType());
setParent.TypeArguments.Add(item.GetRowCodeType());
var invokeSetParent = new CodeMethodInvokeExpression(setParent, target, childs);
cmm.Statements.AddExpression(invokeSetParent);
}
// create and assign child table
{
var target = new CodeVariableReferenceExpression("target");
var childName = new CodeVariableReferenceExpression("childName");
var childs = new CodeVariableReferenceExpression("childs");
var field = item.GetFieldExpression(target);
var createFromRows = new CodeMethodReferenceExpression(item.GetCodeTypeExpression(), "createFromRows");
var InvokeCreateFromRows = new CodeMethodInvokeExpression(createFromRows, childName, childs);
cmm.Statements.AddAssign(field, InvokeCreateFromRows);
}
classType.Members.Add(cmm);
}
}
private static void CreateCreateFromDataSetMethod(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Static;
cmm.Name = "createFromDataSet";
cmm.Parameters.Add("reader", "IDataSet", "dataSet");
cmm.Parameters.Add(typeof(bool), "verifyRevision");
cmm.ReturnType = new CodeTypeReference(generationInfo.ClassName);
// create instance
{
var create = new CodeObjectCreateExpression(cmm.ReturnType);
cmm.Statements.AddVariableDeclaration(cmm.ReturnType.BaseType, "instance", create);
}
// invoke readFromDataSet
{
var instance = new CodeVariableReferenceExpression("instance");
var dataSet = new CodeVariableReferenceExpression("dataSet");
var verifyRevision = new CodeVariableReferenceExpression("verifyRevision");
var readFromDataSet = new CodeMethodReferenceExpression(instance, "readFromDataSet");
cmm.Statements.Add(new CodeMethodInvokeExpression(readFromDataSet, dataSet, verifyRevision));
}
// return instance;
{
var instance = new CodeVariableReferenceExpression("instance");
cmm.Statements.AddMethodReturn(instance);
}
classType.Members.Add(cmm);
}
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"), "tablesHashValue");
ccs.Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityInequality, right);
var message = string.Format("테이블 해시값이 '{0}'이 아닙니다.", generationInfo.TablesHashValue);
var exception = new CodeObjectCreateExpression("Error", new CodePrimitiveExpression(message));
ccs.TrueStatements.Add(new CodeThrowExceptionStatement(exception));
return(ccs);
}
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(int), 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 CodeObjectCreateExpression("Error", new CodePrimitiveExpression(message));
ccs.TrueStatements.Add(new CodeThrowExceptionStatement(exception));
return(ccs);
}
private static CodeStatement CreateCompareTypeStatement(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var table = new CodeVariableReferenceExpression("table");
var version = new CodePropertyReferenceExpression(table, "hashValue");
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("Error", new CodePrimitiveExpression(message));
state.TrueStatements.Add(new CodeThrowExceptionStatement(exception));
return(state);
}
private static void CreateReadFromDataSetMethod(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberMethod();
cmm.Attributes = MemberAttributes.Public;
cmm.Name = "readFromDataSet";
cmm.Parameters.Add("reader", "IDataSet", "dataSet");
cmm.Parameters.Add(typeof(bool), "verifyRevision");
var dataSet = new CodeVariableReferenceExpression("dataSet");
{
var ccs = CreateCompareDataBaseStatement(classType, generationInfo);
var tst = CreateTryCatchStatement(classType, ccs, generationInfo.IsDevmode);
cmm.Statements.Add(tst);
}
{
var ccs = CreateCompareTypesHashValueStatement(classType, generationInfo);
var tst = CreateTryCatchStatement(classType, ccs, generationInfo.IsDevmode);
cmm.Statements.Add(tst);
}
{
var ccs = CreateCompareTablesHashValueStatement(classType, generationInfo);
var tst = CreateTryCatchStatement(classType, ccs, generationInfo.IsDevmode);
cmm.Statements.Add(tst);
}
{
var ccs = CreateCompareRevisionStatement(classType, generationInfo);
var tst = CreateTryCatchStatement(classType, ccs, generationInfo.IsDevmode);
cmm.Statements.Add(tst);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_name");
var property = new CodePropertyReferenceExpression(dataSet, "name");
cmm.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_revision");
var property = new CodePropertyReferenceExpression(dataSet, "revision");
cmm.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_typesHashValue");
var property = new CodePropertyReferenceExpression(dataSet, "typesHashValue");
cmm.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_tablesHashValue");
var property = new CodePropertyReferenceExpression(dataSet, "tablesHashValue");
cmm.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_tags");
var property = new CodePropertyReferenceExpression(dataSet, "tags");
cmm.Statements.AddAssign(field, property);
}
foreach (var item in generationInfo.GetTables(true))
{
var tableName = new CodePrimitiveExpression(item.Name);
var tablesProp = new CodePropertyReferenceExpression(dataSet, "tables");
var table = new CodePropertyReferenceExpression(tablesProp, item.Name);
var field = item.GetFieldExpression();
var createFromTable = new CodeMethodReferenceExpression(item.GetCodeTypeExpression(), "createFromTable");
var invoke = new CodeMethodInvokeExpression(createFromTable, table);
var assignStatement = new CodeAssignStatement(field, invoke);
var tryStatement = CreateTryCatchStatement(classType, assignStatement, generationInfo.IsDevmode);
cmm.Statements.Add(tryStatement);
}
classType.Members.Add(cmm);
}