public void Compile(string outputPath, GenerationSet metaData, CodeGenerationSettings settings, string target)
{
var path = PathUtility.GetFullPath(outputPath);
var generationInfo = new CodeGenerationInfo(path, metaData, settings);
if (settings.Options.HasFlag(CodeGenerationOptions.OmitCode) == false && settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == false)
{
var filename = this.CompileAll(path, generationInfo, target);
this.PrintResult(filename);
}
else if (settings.Options.HasFlag(CodeGenerationOptions.OmitCode) == true)
{
var filename = this.CompileBase(path, generationInfo, target);
this.PrintResult(filename);
}
else if (settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == true)
{
var tempPath = PathUtility.GetTempPath(true);
try
{
var readerPath = this.CompileBase(tempPath, generationInfo, target);
var filename = this.Compile(path, readerPath, generationInfo, target);
this.PrintResult(filename);
}
finally
{
DirectoryUtility.Delete(tempPath);
}
}
}
public static void Create(CodeNamespace codeNamespace, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration()
{
Attributes = MemberAttributes.Public,
Name = tableInfo.GetRowClassName(),
IsClass = true
};
classType.TypeAttributes |= TypeAttributes.Sealed;
classType.BaseTypes.Add(generationInfo.BaseNamespace, "CremaRow");
CreateChildStaticEmptyFields(classType, tableInfo, generationInfo);
CreateConstructor(classType, tableInfo, generationInfo);
CreateTableField(classType, tableInfo);
CreateColumnFields(classType, tableInfo, generationInfo);
CreateChildFields(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);
}
public void Generate(string outputPath, GenerationSet metaData, CodeGenerationSettings settings)
{
var path = PathUtility.GetFullPath(outputPath);
var generationInfo = new CodeGenerationInfo(path, 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, path, 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, path, item.Key);
this.PrintResult(codePath);
}
}
}
private string GenerateReader(CodeGenerationInfo generationInfo)
{
var assembly = System.Reflection.Assembly.GetExecutingAssembly();
var resourceName = string.Join(".", this.GetType().Namespace, "Code", "CremaReader.cs");
var code = this.GetResourceString(resourceName);
code = code.Replace("namespace JSSoft.Crema.Code", "namespace " + generationInfo.BaseNamespace);
code = code.Replace("JSSoft.Crema.Reader", generationInfo.ReaderNamespace);
return(code);
}
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 static void CreateTableFields(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetTables(true))
{
var cmf = new CodeMemberField()
{
Attributes = MemberAttributes.Private,
Name = item.GetFieldName(),
Type = item.GetCodeType()
};
classType.Members.Add(cmf);
}
}
private static void CreateTagsProperty(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberProperty
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = "Tags",
HasGet = true,
Type = new CodeTypeReference(typeof(string))
};
cmm.GetStatements.AddMethodReturn(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "_tags"));
classType.Members.Add(cmm);
}
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)
{
CreateType(codeNamespace, item, 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.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()
{
Attributes = MemberAttributes.Public,
Name = generationInfo.ClassName,
IsClass = true
};
classType.TypeAttributes |= TypeAttributes.Sealed;
classType.BaseTypes.Add(generationInfo.BaseNamespace, "CremaData");
CreateNameField(classType, generationInfo);
CreateRevisionField(classType, generationInfo);
CreateTypesHashValueField(classType, generationInfo);
CreateTablesHashValueField(classType, generationInfo);
CreateTagsField(classType, generationInfo);
CreateNameProperty(classType, generationInfo);
CreateRevisionProperty(classType, generationInfo);
CreateTypesHashValueProperty(classType, generationInfo);
CreateTablesHashValueProperty(classType, generationInfo);
CreateTagsProperty(classType, generationInfo);
CreateTableFields(classType, generationInfo);
CreateConstructor(classType, generationInfo);
CreateConstructorFromFile(classType, generationInfo);
CreateConstructorFromStream(classType, generationInfo);
CreateLoadFromFile(classType, generationInfo);
CreateLoadStream(classType, generationInfo);
CreateLoad(classType, generationInfo);
CreateTableProperties(classType, generationInfo);
codeNamespace.Types.Add(classType);
}
private IDictionary <string, string> GenerateCodes(CodeGenerationInfo generationInfo)
{
var codes = new Dictionary <string, string>();
var cremaTypes = this.GenerateTypeCode(generationInfo);
var cremaTables = this.GenerateTableCode(generationInfo);
codes.Add($"{generationInfo.Prefix}Types{generationInfo.Postfix}.cs", cremaTypes);
codes.Add($"{generationInfo.Prefix}Tables{generationInfo.Postfix}.cs", cremaTables);
foreach (var item in codes.ToArray())
{
codes[item.Key] = item.Value.Replace("JSSoft.Crema.Reader", generationInfo.ReaderNamespace);
}
return(codes);
}
private string GenerateTypeCode(CodeGenerationInfo generationInfo)
{
var sb = new StringBuilder();
using (var sw = new StringWriter(sb))
{
var codeDomProvider = new CSharpCodeProvider();
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, this.options);
}
return(sb.ToString());
}
private static void CreateTableProperties(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetTables(true))
{
var cmp = new CodeMemberProperty()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = item.GetPropertyName(),
Type = item.GetCodeType(),
HasGet = true,
HasSet = false
};
cmp.Comments.AddSummary(item.Comment);
cmp.GetStatements.AddMethodReturn(item.GetFieldExpression());
classType.Members.Add(cmp);
}
}
private string CompileAll(string outputPath, CodeGenerationInfo generationInfo, string target)
{
var sourceList = new List <string>();
sourceList.AddRange(this.GenerateCodes(generationInfo).Values);
sourceList.AddRange(this.GenerateBaseCodes(generationInfo).Values);
sourceList.Add(this.GenerateAssemblyInfo(generationInfo.Namespace));
var providerOptions = new Dictionary <string, string>
{
{ "CompilerVersion", target == string.Empty ? "v3.5" : target }
};
var codeDomProvider = new CSharpCodeProvider(providerOptions);
var cp = new CompilerParameters()
{
OutputAssembly = Path.Combine(outputPath, generationInfo.Namespace + ".dll"),
CompilerOptions = "/optimize",
GenerateExecutable = false,
GenerateInMemory = false
};
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add("System.Core.dll");
cp.ReferencedAssemblies.Add("System.Data.dll");
cp.ReferencedAssemblies.Add("System.Xml.dll");
FileUtility.Prepare(cp.OutputAssembly);
var result = codeDomProvider.CompileAssemblyFromSource(cp, sourceList.ToArray());
if (result.Errors.HasErrors)
{
foreach (var item in result.Errors)
{
Trace.WriteLine(item);
}
throw new Exception("에러가 발생했습니다.");
}
return(cp.OutputAssembly);
}
private static void CreateConstructor(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cc = new CodeConstructor()
{
Attributes = MemberAttributes.Public
};
cc.Parameters.Add("IDataSet", "dataSet");
cc.Parameters.Add(new CodeTypeReference(typeof(bool)), "verifyRevision");
//cc.BaseConstructorArgs.Add(new CodePrimitiveExpression(generationInfo.DataBaseName));
//cc.BaseConstructorArgs.Add(new CodePrimitiveExpression(generationInfo.Revision));
var methodInvokeExp = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Load", new CodeVariableReferenceExpression("dataSet"), new CodeVariableReferenceExpression("verifyRevision"));
cc.Statements.Add(methodInvokeExp);
classType.Members.Add(cc);
}
private static void CreateConstructorFromFile(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cc = new CodeConstructor()
{
Attributes = MemberAttributes.Public
};
cc.Parameters.Add(typeof(string), "filename");
cc.Parameters.Add(new CodeTypeReference(typeof(bool)), "verifyRevision");
var readerRef = new CodeTypeReferenceExpression(string.Join(".", generationInfo.ReaderNamespace, "CremaReader"));
var paramExp = new CodeVariableReferenceExpression("filename");
var methodInvokeExp = new CodeMethodInvokeExpression(readerRef, "Read", paramExp);
cc.ChainedConstructorArgs.Add(methodInvokeExp);
cc.ChainedConstructorArgs.Add(new CodeVariableReferenceExpression("verifyRevision"));
classType.Members.Add(cc);
}
private static void CreateLoadStream(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cc = new CodeMemberMethod()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = "Load",
};
cc.Parameters.Add(typeof(Stream), "stream");
cc.Parameters.Add(typeof(bool), "verifyRevision");
var readerRef = new CodeTypeReferenceExpression(string.Join(".", generationInfo.ReaderNamespace, "CremaReader"));
var paramExp = new CodeVariableReferenceExpression("stream");
var readExp = new CodeMethodInvokeExpression(readerRef, "Read", paramExp);
var methodInvokeExp = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Load", readExp, new CodeVariableReferenceExpression("verifyRevision"));
cc.Statements.Add(methodInvokeExp);
classType.Members.Add(cc);
}
private IDictionary <string, string> GenerateBaseCodes(CodeGenerationInfo generationInfo)
{
var codes = new Dictionary <string, string>
{
{ $"{generationInfo.RelativePath}CremaBase.cs", this.GenerateBase(generationInfo) },
{ $"{generationInfo.RelativePath}CremaReader.cs", this.GenerateReader(generationInfo) }
};
//var assembly = System.Reflection.Assembly.GetExecutingAssembly();
//var ns = string.Join(".", this.GetType().Namespace, "Reader");
//var files = assembly.GetManifestResourceNames().Where(item => item.StartsWith(ns));
//foreach (var item in files)
//{
// var value = this.GetResourceString(item);
// var key = Regex.Replace(item, "(^" + this.GetType().Namespace + @"[.])(\S+)[.]cs", "$2").Replace('.', Path.DirectorySeparatorChar);
// value = value.Replace("JSSoft.Crema.Reader", generationInfo.ReaderNamespace);
// codes.Add($"{generationInfo.RelativePath}{key}.cs", value);
//}
return(codes);
}
public static CodeStatement CreateTryCatchStatement(CodeTypeDeclaration classType, CodeStatement statement, CodeGenerationInfo generationInfo)
{
var tryStatement = new CodeTryCatchFinallyStatement();
tryStatement.TryStatements.Add(statement);
var catchClause = new CodeCatchClause("e");
var methodRefExp = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression($"{generationInfo.BaseNamespace}.CremaData"), "InvokeErrorOccuredEvent");
var methodInvokeExp = new CodeMethodInvokeExpression(methodRefExp, new CodeThisReferenceExpression(), 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 CodeObjectCreateExpression(typeof(Exception), new CodePrimitiveExpression(message));
ccs.TrueStatements.Add(new CodeThrowExceptionStatement(exception));
return(ccs);
}
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 CodeObjectCreateExpression(typeof(Exception), new CodePrimitiveExpression(message));
ccs.TrueStatements.Add(new CodeThrowExceptionStatement(exception));
return(ccs);
}
public static void CreateTypeMember(CodeTypeDeclaration classType, TypeMemberInfo typeMemberInfo, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberField()
{
Name = typeMemberInfo.Name,
InitExpression = new CodePrimitiveExpression((int)typeMemberInfo.Value)
};
if (generationInfo.OmitComment == false)
{
cmm.Comments.AddSummary(typeMemberInfo.Comment);
}
if (generationInfo.OmitSignatureDate == 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 static void CreateSetChildsMethod(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in generationInfo.GetChilds(tableInfo))
{
var cmm = new CodeMemberMethod()
{
Attributes = MemberAttributes.FamilyAndAssembly | MemberAttributes.Static,
Name = "Set" + item.TableName
};
cmm.Parameters.Add(tableInfo.GetRowCodeType(), "target");
cmm.Parameters.Add(typeof(string), "childName");
cmm.Parameters.Add(item.GetRowCodeType(), 1, "childs");
{
var methodRefExp = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(tableInfo.GetRowCodeType()), "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 CodeVariableReferenceExpression("target");
var childName = new CodeVariableReferenceExpression("childName");
var childs = new CodeVariableReferenceExpression("childs");
var targetField = item.GetFieldExpression(target);
var targetInstance = new CodeObjectCreateExpression(item.GetCodeType(), childName, childs);
cmm.Statements.AddAssign(targetField, targetInstance);
}
classType.Members.Add(cmm);
}
}
private static void CreateColumnProperties(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in tableInfo.Columns)
{
var cmp = new CodeMemberProperty()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = item.Name,
Type = item.GetCodeType()
};
if (generationInfo.OmitComment == false)
{
cmp.Comments.AddSummary(item.Comment);
}
if (generationInfo.OmitSignatureDate == 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;
cmp.GetStatements.AddMethodReturn(item.GetFieldExpression());
classType.Members.Add(cmp);
}
}
private static void CreateColumnFields(CodeTypeDeclaration classType, TableInfo tableInfo, CodeGenerationInfo generationInfo)
{
foreach (var item in tableInfo.Columns)
{
var cmf = new CodeMemberField()
{
Attributes = MemberAttributes.Private,
Name = item.GetFieldName(),
Type = item.GetCodeType()
};
classType.Members.Add(cmf);
}
}
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(), "table");
cc.BaseConstructorArgs.Add("row");
// assign table field
{
var leftExp = tableInfo.GetFieldExpression();
var rightExp = new CodeVariableReferenceExpression("table");
cc.Statements.AddAssign(leftExp, rightExp);
}
// assign fields
{
var 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++;
}
}
// 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)
{
var getHashCode = new CodeMethodReferenceExpression(item.GetFieldExpression(), "GetHashCode");
methodInvokeExp.Parameters.Add(new CodeMethodInvokeExpression(getHashCode));
}
}
cc.Statements.Add(methodInvokeExp);
}
classType.Members.Add(cc);
}
public static void CreateType(CodeNamespace codeNamespace, TypeInfo typeInfo, CodeGenerationInfo generationInfo)
{
var classType = new CodeTypeDeclaration(typeInfo.Name)
{
Attributes = MemberAttributes.Public,
IsEnum = true
};
if (typeInfo.IsFlag == true)
{
classType.CustomAttributes.Add(typeof(FlagsAttribute));
}
if (generationInfo.OmitComment == false)
{
classType.Comments.AddSummary(typeInfo.Comment);
}
if (generationInfo.OmitSignatureDate == false)
{
classType.Comments.Add(CremaSchema.Creator, typeInfo.CreationInfo.ID);
classType.Comments.Add(CremaSchema.CreatedDateTime, typeInfo.CreationInfo.DateTime);
classType.Comments.Add(CremaSchema.Modifier, typeInfo.ModificationInfo.ID);
classType.Comments.Add(CremaSchema.ModifiedDateTime, typeInfo.ModificationInfo.DateTime);
}
foreach (var item in typeInfo.Members)
{
CreateTypeMember(classType, item, generationInfo);
}
codeNamespace.Types.Add(classType);
}
private static void CreateConstructorFromStream(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cc = new CodeConstructor()
{
Attributes = MemberAttributes.Public
};
cc.Parameters.Add(typeof(Stream), "stream");
cc.Parameters.Add(typeof(bool), "verifyRevision");
var readerRef = new CodeTypeReferenceExpression(string.Join(".", generationInfo.ReaderNamespace, "CremaReader"));
var paramExp = new CodeVariableReferenceExpression("stream");
var methodInvokeExp = new CodeMethodInvokeExpression(readerRef, "Read", paramExp);
cc.ChainedConstructorArgs.Add(methodInvokeExp);
var left = new CodeVariableReferenceExpression("verifyRevision");
var right = new CodePrimitiveExpression(false);
cc.ChainedConstructorArgs.Add(new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.Assign, right));
classType.Members.Add(cc);
}
private static void CreateChildStaticEmptyFields(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(),
InitExpression = new CodeObjectCreateExpression(item.GetCodeType())
};
classType.Members.Add(cmf);
}
}
private static void CreateLoad(CodeTypeDeclaration classType, CodeGenerationInfo generationInfo)
{
var cc = new CodeMemberMethod()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = "Load",
};
cc.Parameters.Add("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 field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_name");
var property = new CodePropertyReferenceExpression(dataSet, "Name");
cc.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_revision");
var property = new CodePropertyReferenceExpression(dataSet, "Revision");
cc.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_typesHashValue");
var property = new CodePropertyReferenceExpression(dataSet, "TypesHashValue");
cc.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_tablesHashValue");
var property = new CodePropertyReferenceExpression(dataSet, "TablesHashValue");
cc.Statements.AddAssign(field, property);
}
{
var field = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_tags");
var property = new CodePropertyReferenceExpression(dataSet, "Tags");
cc.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 CodeIndexerExpression(tablesProp, tableName);
var field = item.GetFieldExpression();
var instance = new CodeObjectCreateExpression(item.GetCodeType(), table);
var assignStatement = new CodeAssignStatement(field, instance);
cc.Statements.Add(assignStatement);
}
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()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = item.GetPropertyName(),
Type = item.GetCodeType()
};
if (generationInfo.OmitComment == false)
{
cmp.Comments.AddSummary(item.Comment);
}
if (generationInfo.OmitSignatureDate == 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;
{
var state = new CodeConditionStatement();
var testExp = new CodeBinaryOperatorExpression(item.GetFieldExpression(), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
state.Condition = testExp;
var staticRefExp = new CodeTypeReferenceExpression(tableInfo.GetRowCodeType());
var fieldExp = new CodeFieldReferenceExpression(staticRefExp, item.GetFieldName() + "Empty");
state.TrueStatements.AddMethodReturn(fieldExp);
cmp.GetStatements.Add(state);
}
{
var fieldExp = item.GetFieldExpression();
cmp.GetStatements.AddMethodReturn(fieldExp);
}
classType.Members.Add(cmp);
}
}