internal string WriteApiStation(GenerationInfo GenInfo, Microsoft.SqlServer.Management.Smo.Database datab, Microsoft.SqlServer.Management.Smo.Table t, string RepositoryPath)
{
string module_folder_name = String.Format(@"{0}\Modules",RepositoryPath);
string file_path = string.Format(@"{0}\{1}Module.cs", module_folder_name, t.Name);
#region [ Build Module Folder Name ]
if (Directory.Exists(module_folder_name) == false)
{
Directory.CreateDirectory(module_folder_name);
}
#endregion
return "";
}
public BoundClass(ClassGen klass, CodeGenerationOptions opt, CodeGeneratorContext context, GenerationInfo generationInfo)
{
context.ContextTypes.Push(klass);
context.ContextGeneratedMethods = new List <Method> ();
generationInfo.TypeRegistrations.Add(new KeyValuePair <string, string> (klass.RawJniName, klass.AssemblyQualifiedName));
var is_enum = klass.base_symbol != null && klass.base_symbol.FullName == "Java.Lang.Enum";
if (is_enum)
{
generationInfo.Enums.Add(klass.RawJniName.Replace('/', '.') + ":" + klass.Namespace + ":" + klass.JavaSimpleName);
}
this.opt = opt;
Name = klass.Name;
SetVisibility(klass.Visibility);
IsShadow = klass.NeedsNew;
IsAbstract = klass.IsAbstract;
IsSealed = klass.IsFinal;
IsPartial = true;
UsePriorityOrder = true;
AddImplementedInterfaces(klass);
klass.JavadocInfo?.AddJavadocs(Comments);
Comments.Add($"// Metadata.xml XPath class reference: path=\"{klass.MetadataXPathReference}\"");
if (klass.IsDeprecated)
{
Attributes.Add(new ObsoleteAttr(klass.DeprecatedComment)
{
WriteAttributeSuffix = true
});
}
SourceWriterExtensions.AddSupportedOSPlatform(Attributes, klass, opt);
Attributes.Add(new RegisterAttr(klass.RawJniName, null, null, true, klass.AdditionalAttributeString())
{
UseGlobal = true, UseShortForm = true
});
if (klass.TypeParameters != null && klass.TypeParameters.Any())
{
Attributes.Add(new CustomAttr(klass.TypeParameters.ToGeneratedAttributeString()));
}
// Figure out our base class
string obj_type = null;
if (klass.base_symbol != null)
{
obj_type = klass.base_symbol is GenericSymbol gs &&
gs.IsConcrete ? gs.GetGenericType(null) : opt.GetOutputName(klass.base_symbol.FullName);
}
if (klass.InheritsObject && obj_type != null)
{
Inherits = obj_type;
}
// Handle fields
var seen = new HashSet <string> ();
SourceWriterExtensions.AddFields(this, klass, klass.Fields, seen, opt, context);
var ic = new InterfaceConstsClass(klass, seen, opt, context);
if (ic.ShouldGenerate)
{
NestedTypes.Add(ic);
}
// Sibling classes
if (!klass.AssemblyQualifiedName.Contains('/'))
{
foreach (InterfaceExtensionInfo nestedIface in klass.GetNestedInterfaceTypes())
{
if (nestedIface.Type.Methods.Any(m => m.CanHaveStringOverload) || nestedIface.Type.Methods.Any(m => m.Asyncify))
{
sibling_types.Add(new InterfaceExtensionsClass(nestedIface.Type, nestedIface.DeclaringType, opt));
}
}
}
if (klass.IsAbstract)
{
sibling_types.Add(new ClassInvokerClass(klass, opt));
}
AddNestedTypes(klass, opt, context, generationInfo);
AddBindingInfrastructure(klass);
AddConstructors(klass, opt, context);
AddProperties(klass, opt);
AddMethods(klass, opt, context);
AddAbstractMembers(klass, opt, context);
AddExplicitGenericInterfaceMembers(klass, opt);
AddCharSequenceEnumerator(klass);
context.ContextGeneratedMethods.Clear();
context.ContextTypes.Pop();
}
protected void GenerateStructAbi(GenerationInfo generationInfo, IList <StructAbiField> fields,
string infoName, string structName)
{
if (fields == null)
{
fields = AbiFields;
}
var logWriter = new LogWriter(QualifiedName);
if (!CheckStructAbiParent(logWriter, out var csParentStruct))
{
return;
}
var streamWriter = generationInfo.Writer;
streamWriter.WriteLine();
streamWriter.WriteLine("\t\t// Internal representation of the wrapped structure ABI.");
streamWriter.WriteLine($"\t\tstatic GLib.AbiStruct _{infoName} = null;");
streamWriter.WriteLine(
$"\t\tstatic public {(!string.IsNullOrEmpty(csParentStruct) ? "new " : "")}GLib.AbiStruct {infoName} {{");
streamWriter.WriteLine("\t\t\tget {");
streamWriter.WriteLine($"\t\t\t\tif (_{infoName} == null)");
// Generate Tests
var usingParentFields = false;
if (fields.Count > 0)
{
streamWriter.WriteLine($"\t\t\t\t\t_{infoName} = new GLib.AbiStruct (new List<GLib.AbiField>{{ ");
if (generationInfo.CAbiWriter != null)
{
generationInfo.CAbiWriter.WriteLine(
"\tg_print(\"\\\"sizeof({0})\\\": \\\"%\" G_GUINT64_FORMAT \"\\\"\\n\", (guint64) sizeof({0}));",
structName);
generationInfo.AbiWriter.WriteLine(
"\t\t\tConsole.WriteLine(\"\\\"sizeof({0})\\\": \\\"\" + {1}.{2}.{3}.Size + \"\\\"\");",
structName, Namespace, Name, infoName);
}
}
else
{
if (!string.IsNullOrEmpty(csParentStruct))
{
streamWriter.WriteLine("\t\t\t\t\t_{1} = new GLib.AbiStruct ({0}.{1}.Fields);", csParentStruct, infoName);
usingParentFields = true;
}
else
{
streamWriter.WriteLine("\t\t\t\t\t_{0} = new GLib.AbiStruct (new List<GLib.AbiField>{{ ", infoName);
}
}
StructAbiField previous = null;
var fieldAlignmentStructuresWriter = new StringWriter();
for (var i = 0; i < fields.Count; i++)
{
var field = fields[i];
var next = fields.Count > i + 1 ? fields[i + 1] : null;
previous = field.Generate(generationInfo, "\t\t\t\t\t", previous, next, csParentStruct,
fieldAlignmentStructuresWriter);
if (field is UnionAbiField || generationInfo.CAbiWriter == null || field.IsBitfield)
{
continue;
}
generationInfo.CAbiWriter.WriteLine(
"\tg_print(\"\\\"{0}.{1}\\\": \\\"%\" G_GUINT64_FORMAT \"\\\"\\n\", (guint64) G_STRUCT_OFFSET({0}, {1}));",
structName, field.CName);
generationInfo.AbiWriter.WriteLine(
"\t\t\tConsole.WriteLine(\"\\\"{0}.{3}\\\": \\\"\" + {1}.{2}.{4}.GetFieldOffset(\"{3}\") + \"\\\"\");",
structName, Namespace, Name, field.CName, infoName);
}
if (fields.Count > 0 && generationInfo.CAbiWriter != null)
{
generationInfo.AbiWriter.Flush();
generationInfo.CAbiWriter.Flush();
}
if (!usingParentFields)
{
streamWriter.WriteLine("\t\t\t\t\t});");
}
streamWriter.WriteLine();
streamWriter.WriteLine($"\t\t\t\treturn _{infoName};");
streamWriter.WriteLine("\t\t\t}");
streamWriter.WriteLine("\t\t}");
streamWriter.WriteLine();
streamWriter.WriteLine(fieldAlignmentStructuresWriter.ToString());
streamWriter.WriteLine("\t\t// End of the ABI representation.");
streamWriter.WriteLine();
}
public WebConfigGenerator(string ns, string name, GenerationInfo generationInfo) : base(ns, name, generationInfo)
{
}
static void Run(CodeGeneratorOptions options, DirectoryAssemblyResolver resolver)
{
string assemblyQN = options.AssemblyQualifiedName;
string api_level = options.ApiLevel;
int product_version = options.ProductVersion;
bool preserve_enums = options.PreserveEnums;
string csdir = options.ManagedCallableWrapperSourceOutputDirectory ?? "cs";
string javadir = "java";
string enumdir = options.EnumOutputDirectory ?? "enum";
string enum_metadata = options.EnumMetadataOutputFile ?? "enummetadata";
var references = options.AssemblyReferences;
string enum_fields_map = options.EnumFieldsMapFile;
string enum_flags = options.EnumFlagsFile;
string enum_methods_map = options.EnumMethodsMapFile;
var fixups = options.FixupFiles;
var annotations_zips = options.AnnotationsZipFiles;
string filename = options.ApiDescriptionFile;
string mapping_file = options.MappingReportFile;
bool only_xml_adjuster = options.OnlyRunApiXmlAdjuster;
string api_xml_adjuster_output = options.ApiXmlAdjusterOutput;
var apiSource = "";
var opt = new CodeGenerationOptions()
{
ApiXmlFile = options.ApiDescriptionFile,
CodeGenerationTarget = options.CodeGenerationTarget,
UseGlobal = options.GlobalTypeNames,
IgnoreNonPublicType = true,
UseShortFileNames = options.UseShortFileNames,
ProductVersion = options.ProductVersion,
SupportInterfaceConstants = options.SupportInterfaceConstants,
SupportDefaultInterfaceMethods = options.SupportDefaultInterfaceMethods,
SupportNestedInterfaceTypes = options.SupportNestedInterfaceTypes,
SupportNullableReferenceTypes = options.SupportNullableReferenceTypes,
};
var resolverCache = new TypeDefinitionCache();
// Load reference libraries
foreach (var lib in options.LibraryPaths)
{
resolver.SearchDirectories.Add(lib);
}
foreach (var reference in references)
{
resolver.SearchDirectories.Add(Path.GetDirectoryName(reference));
}
// Figure out if this is class-parse
string apiXmlFile = filename;
string apiSourceAttr = null;
using (var xr = XmlReader.Create(filename, new XmlReaderSettings {
XmlResolver = null
})) {
xr.MoveToContent();
apiSourceAttr = xr.GetAttribute("api-source");
}
// We don't use shallow referenced types with class-parse because the Adjuster process
// enumerates every ctor/method/property/field to build its model, so we will need
// every type to be fully populated.
opt.UseShallowReferencedTypes = apiSourceAttr != "class-parse";
foreach (var reference in references.Distinct())
{
try {
Report.Verbose(0, "resolving assembly {0}.", reference);
var assembly = resolver.Load(reference);
foreach (var md in assembly.Modules)
{
foreach (var td in md.Types)
{
// FIXME: at some stage we want to import generic types.
// For now generator fails to load generic types that have conflicting type e.g.
// AdapterView`1 and AdapterView cannot co-exist.
// It is mostly because generator primarily targets jar (no real generics land).
var nonGenericOverload = td.HasGenericParameters
? md.GetType(td.FullName.Substring(0, td.FullName.IndexOf('`')))
: null;
if (BindSameType(td, nonGenericOverload, resolverCache))
{
continue;
}
ProcessReferencedType(td, opt);
}
}
} catch (Exception ex) {
Report.LogCodedWarning(0, Report.WarningAssemblyParseFailure, ex, reference, ex.Message);
}
}
// For class-parse API description, transform it to jar2xml style.
if (apiSourceAttr == "class-parse")
{
apiXmlFile = api_xml_adjuster_output ?? Path.Combine(Path.GetDirectoryName(filename), Path.GetFileName(filename) + ".adjusted");
new Adjuster().Process(filename, opt, opt.SymbolTable.AllRegisteredSymbols(opt).OfType <GenBase> ().ToArray(), apiXmlFile, Report.Verbosity ?? 0);
}
if (only_xml_adjuster)
{
return;
}
// load XML API definition with fixups.
Dictionary <string, EnumMappings.EnumDescription> enums = null;
EnumMappings enummap = null;
if (enum_fields_map != null || enum_methods_map != null)
{
enummap = new EnumMappings(enumdir, enum_metadata, api_level, preserve_enums);
enums = enummap.Process(enum_fields_map, enum_flags, enum_methods_map);
fixups.Add(enum_metadata);
}
Parser p = new Parser(opt);
List <GenBase> gens = p.Parse(apiXmlFile, fixups, api_level, product_version);
if (gens == null)
{
return;
}
apiSource = p.ApiSource;
// disable interface default methods here, especially before validation.
gens = gens.Where(g => !g.IsObfuscated && g.Visibility != "private").ToList();
foreach (var gen in gens)
{
gen.StripNonBindables(opt);
if (gen.IsGeneratable)
{
AddTypeToTable(opt, gen);
}
}
// Apply fixups
KotlinFixups.Fixup(gens);
Validate(gens, opt, new CodeGeneratorContext());
foreach (var api_versions_xml in options.ApiVersionsXmlFiles)
{
ApiVersionsSupport.AssignApiLevels(gens, api_versions_xml);
}
foreach (GenBase gen in gens)
{
gen.FillProperties();
}
var cache = new AncestorDescendantCache(gens);
foreach (var gen in gens)
{
gen.UpdateEnums(opt, cache);
}
foreach (GenBase gen in gens)
{
gen.FixupMethodOverrides(opt);
}
foreach (GenBase gen in gens)
{
gen.FixupExplicitImplementation();
}
SealedProtectedFixups.Fixup(gens);
GenerateAnnotationAttributes(gens, annotations_zips);
//SymbolTable.Dump ();
GenerationInfo gen_info = new GenerationInfo(csdir, javadir, assemblyQN);
opt.AssemblyName = gen_info.Assembly;
if (mapping_file != null)
{
GenerateMappingReportFile(gens, mapping_file);
}
foreach (IGeneratable gen in gens)
{
if (gen.IsGeneratable)
{
gen.Generate(opt, gen_info);
}
}
new NamespaceMapping(gens).Generate(opt, gen_info);
ClassGen.GenerateTypeRegistrations(opt, gen_info);
ClassGen.GenerateEnumList(gen_info);
// Create the .cs files for the enums
var enumFiles = enums == null
? null
: enummap.WriteEnumerations(enumdir, enums, FlattenNestedTypes(gens).ToArray(), opt.UseShortFileNames);
gen_info.GenerateLibraryProjectFile(options, enumFiles);
}
protected void GenerateStructAbi(GenerationInfo generationInfo)
{
GenerateStructAbi(generationInfo, null, "abi_info", CName);
}
void AddNestedSiblingTypes(InterfaceGen iface, CodeGenerationOptions opt, CodeGeneratorContext context, GenerationInfo genInfo)
{
// Generate sibling types for nested types we don't want to nest
foreach (var nest in iface.NestedTypes.Where(t => t.Unnest))
{
pre_sibling_types.Add(SourceWriterExtensions.BuildManagedTypeModel(nest, opt, context, genInfo));
}
}
void AddNestedTypes(InterfaceGen iface, CodeGenerationOptions opt, CodeGeneratorContext context, GenerationInfo genInfo)
{
// Generate nested types for supported nested types. This is a new addition in C#8.
// Prior to this, types nested in an interface had to be generated as sibling types.
// The "Unnest" property is used to support backwards compatibility with pre-C#8 bindings.
foreach (var nest in iface.NestedTypes.Where(t => !t.Unnest))
{
NestedTypes.Add(SourceWriterExtensions.BuildManagedTypeModel(nest, opt, context, genInfo));
}
}
public BoundInterface(InterfaceGen iface, CodeGenerationOptions opt, CodeGeneratorContext context, GenerationInfo genInfo)
{
context.ContextTypes.Push(iface);
Name = iface.Name;
AddNestedSiblingTypes(iface, opt, context, genInfo);
AddAlternativesClass(iface, opt, context);
// If this interface is just fields and we can't generate any of them
// then we don't need to write the interface. We still keep this type
// because it may have nested types or need an InterfaceMemberAlternativeClass.
if (iface.IsConstSugar && iface.GetGeneratableFields(opt).Count() == 0)
{
dont_generate = true;
return;
}
IsPartial = true;
UsePriorityOrder = true;
SetVisibility(iface.Visibility);
Comments.Add($"// Metadata.xml XPath interface reference: path=\"{iface.MetadataXPathReference}\"");
if (iface.IsDeprecated)
{
Attributes.Add(new ObsoleteAttr(iface.DeprecatedComment)
{
WriteAttributeSuffix = true, WriteEmptyString = true
});
}
if (!iface.IsConstSugar)
{
var signature = string.IsNullOrWhiteSpace(iface.Namespace)
? iface.FullName.Replace('.', '/')
: iface.Namespace + "." + iface.FullName.Substring(iface.Namespace.Length + 1).Replace('.', '/');
Attributes.Add(new RegisterAttr(iface.RawJniName, string.Empty, signature + "Invoker", additionalProperties: iface.AdditionalAttributeString()));
}
if (iface.TypeParameters != null && iface.TypeParameters.Any())
{
Attributes.Add(new CustomAttr(iface.TypeParameters.ToGeneratedAttributeString()));
}
AddInheritedInterfaces(iface, opt);
AddClassHandle(iface, opt);
AddFields(iface, opt, context);
AddProperties(iface, opt);
AddMethods(iface, opt);
AddNestedTypes(iface, opt, context, genInfo);
// If this interface is just constant fields we don't need to add all the invoker bits
if (iface.IsConstSugar)
{
return;
}
if (!iface.AssemblyQualifiedName.Contains('/'))
{
if (iface.Methods.Any(m => m.CanHaveStringOverload) || iface.Methods.Any(m => m.Asyncify))
{
post_sibling_types.Add(new InterfaceExtensionsClass(iface, null, opt));
}
}
post_sibling_types.Add(new InterfaceInvokerClass(iface, opt, context));
AddInterfaceEventHandler(iface, opt, context);
context.ContextTypes.Pop();
}
protected Modelable(GenerationInfo generationInfo, T modelParameters) : base(generationInfo)
{
ModelParameters = modelParameters;
}
/// <summary>
/// Generates Data Access, Mapping and Transfer Code from the Database
/// </summary>
/// <param name="FolderPath"></param>
/// <param name="ServerName"></param>
/// <param name="DatabaseName"></param>
public static void GenerateFromDatabase(GenerationInfo GenInfo)
{
DirectoryInfo d = new DirectoryInfo(GenInfo.FolderPath);
Microsoft.SqlServer.Management.Common.ServerConnection svrCon = new Microsoft.SqlServer.Management.Common.ServerConnection(GenInfo.ServerName);
Server svr = new Server(svrCon);
String DbScriptsPath = GenInfo.FolderPath + @"\Procedures";
foreach (Microsoft.SqlServer.Management.Smo.Database datab in svr.Databases)
{
if (datab.IsAccessible)
{
if (!(DatabasesToIgnore().Contains(datab.Name)))
{
if (datab.Name.ToLower() == GenInfo.DataBase.ToLower())
{
Console.Write("Generating Code for Database: " + datab.Name + "\n");
String RepositoryPath = GenInfo.FolderPath + @"\" + datab.Name; // The Current Repository
String DataLayerNamespace = String.Format("{0}.{1}.{2}", GenInfo.CompanyName, GenInfo.DataNameSpace, datab.Name);
#region [ Clean / Create Directory ]
if (Directory.Exists(RepositoryPath))
{
// Directory Exists clean it out
DirectoryInfo dRepository = new DirectoryInfo(RepositoryPath);
foreach (FileInfo f in dRepository.GetFiles("*.*", SearchOption.AllDirectories))
{
f.Delete();
}
}
else
{
Directory.CreateDirectory(RepositoryPath);
}
#endregion
#region [ Tables ]
String RepositoryPathProcedures = RepositoryPath + @"\Procedures";
if (Directory.Exists(RepositoryPathProcedures))
{
Directory.Delete(RepositoryPathProcedures);
}
Directory.CreateDirectory(RepositoryPathProcedures);
Int32 GenerationStep = 0;
DALGenerator dg = new DALGenerator();
POCOGenerator pg = new POCOGenerator();
foreach (Table t in datab.Tables)
{
GenerationStep = 0;
try
{
if (t.Name == "Loan")
{
"$".IsNormalized();
}
if (!(t.IsSystemObject))
{
// Check if the table has a primary key, if not then dont generate anything. Table muist be normalized
if (ValidateSqlTable(t))
{
#region [ Generation Root ]
String cpFilename = RepositoryPathProcedures + @"\\" + "cp_" + t.Name + ".sql";
String sspFileName = RepositoryPathProcedures + @"\\" + "ssp_" + t.Name + ".sql";
String EntityFileName = RepositoryPath + @"\\" + t.Name + ".cs";
String DALFileName = RepositoryPath + @"\\" + t.Name + "DAL.cs";
String DOMFileName = RepositoryPath + @"\\" + t.Name + "DomainObject.cs";
GenerationStep = 1;
// [0] Stored Procedures
MGenerator.Tools.SqlGeneration.CrudProcedureGenerator gen = new SqlGeneration.CrudProcedureGenerator(datab, t);
gen.Generate(RepositoryPathProcedures, MGenerator.Tools.SqlGeneration.ProcedureGenerationType.Alter);
GenerationStep = 2;
ObjectiveSearchProcedureGenerator ospgen = new ObjectiveSearchProcedureGenerator(datab, t);
ospgen.Generate(RepositoryPathProcedures);
GenerationStep = 3;
// [1] Data Access Classes
WriteCsharpFile(GenInfo.CompanyName, GenInfo.DataNameSpace, datab.Name, RepositoryPath, dg.BuildDalClass(String.Format("{0}.{1}", GenInfo.CompanyName, GenInfo.DataNameSpace), datab.Name, t));
GenerationStep = 4;
// [2] Entity / Structure Class
WriteCsharpFile(GenInfo.CompanyName, GenInfo.DataNameSpace, datab.Name, RepositoryPath, pg.BuildPoc(t));
GenerationStep = 5;
// [3] Service Layer
DomainServiceGraph svcgen = new DomainServiceGraph();
WriteCsharpFile(GenInfo.CompanyName, GenInfo.DataNameSpace, datab.Name, RepositoryPath, svcgen.BuildDomainObject(String.Format("{0}.{1}", GenInfo.CompanyName, GenInfo.DataNameSpace), datab.Name, t));
GenerationStep = 6;
// [4] API
ApiGraph api = new ApiGraph();
string api_name =
api.WriteApiStation(GenInfo, datab, t, RepositoryPath);
#endregion
Console.Write(t.Name + "....COMPLETE" + "\n");
}
}
}
catch (Exception x)
{
Console.Write(t.Name + "....ERROR" + "\n");
// File.WriteAllText(RepositoryPath + t.Name + ".txt", x.Message + "\n Generation Step:" + GenerationStep.ToString() );
continue;
}
}
#endregion
#region [ Views ]
foreach (View view in datab.Views)
{
try
{
if (view.Name == "vwLOLicense")
{
String fd = "";
}
if (!(view.IsSystemObject))
{
if (ValidateSqlView(view))
{
ObjectiveSearchProcedureGenerator ospgen = new ObjectiveSearchProcedureGenerator(datab, view);
DomainServiceGraph svcgen = new DomainServiceGraph();
ospgen.Generate(RepositoryPathProcedures);
WriteCsharpFile(GenInfo.CompanyName, GenInfo.DataNameSpace, datab.Name, RepositoryPath, dg.BuildDalClass(String.Format("{0}.{1}", GenInfo.CompanyName, GenInfo.DataNameSpace), datab.Name, view));
WriteCsharpFile(GenInfo.CompanyName, GenInfo.DataNameSpace, datab.Name, RepositoryPath, pg.BuildPoco(view));
WriteCsharpFile(GenInfo.CompanyName, GenInfo.DataNameSpace, datab.Name, RepositoryPath, svcgen.BuildDomainObject(String.Format("{0}.{1}", GenInfo.CompanyName, GenInfo.DataNameSpace), datab.Name, view));
Console.Write(view.Name + "....COMPLETE" + "\n");
}
}
}
catch (Exception x)
{
Console.Write(view.Name + "....ERROR" + "\n");
continue;
}
}
#endregion
}
}
}
}
}