private static string AppendCopyright(this string input, IDecl declaration)
{
string package = PyExtensions.GetPackage(declaration);
string dcCopyright = @"# Copyright (C) 2013-present The DataCentric Authors.
#
# Licensed under the Apache License, Version 2.0 (the ""License"");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an ""AS IS"" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
";
if (package == "datacentric")
{
return(dcCopyright + input);
}
else
{
throw new Exception($"Copyright header is not specified for module {package}.");
}
}
/// <summary>
/// Return top level package name for given declaration.
/// </summary>
public static string GetPackage(IDecl decl)
{
if (decl.Module.ModuleName.StartsWith("DataCentric"))
{
return("datacentric");
}
throw new Exception($"Unknown module: {decl.Module.ModuleName}");
}
public Decl(DeclKind kind, IDecl parent)
{
Kind = kind;
Parent = parent as Decl;
if (Parent != null)
{
Parent.Decls.Add(this);
}
}
private static string GetIncludePath(IDecl decl)
{
var settings = GeneratorSettingsProvider.Get(decl.Module.ModuleName);
// Avoid adding trailing path separator
return(!string.IsNullOrEmpty(decl.Category) && !decl.Category.Equals(".")
? $"{settings.Namespace}.{decl.Category}".Underscore().Replace('.', '/')
: $"{settings.Namespace}".Underscore().Replace('.', '/'));
}
int Compare(IDecl decl1, IDecl decl2)
{
if (decl1 is LocalDecl && decl2 is LocalDecl)
{
LocalDecl aDecl1 = (LocalDecl)decl1;
LocalDecl aDecl2 = (LocalDecl)decl2;
if (aDecl1.ParentMethod != aDecl2.ParentMethod)
{
return(aDecl1.ParentMethod.GetHashCode().CompareTo(aDecl2.ParentMethod.GetHashCode()));//Here, I assume that the hash codes will always be diffrent.
}
}
return(decl1.Name.CompareTo(decl2.Name));
}
/// <summary>
/// Translate the exploded guy into a C# declaration
/// </summary>
/// <param name="r"></param>
/// <returns></returns>
internal static string TranslateToCSharp(IDecl r)
{
if (r is RegularDecl)
{
var typ = (r as RegularDecl).Type;
typ = TypeDefTranslator.ResolveTypedef(typ);
if (typ == "string")
{
throw new NotImplementedException("Unable to translate the C++ type of string");
}
var clsInfo = ROOTNET.NTClass.GetClass(typ);
if (clsInfo != null)
{
if (!clsInfo.IsShellTClass())
{
typ = "ROOTNET.Interface.N" + typ;
}
else
{
typ = typ.SanitizedName();
}
}
else
{
typ = typ.SimpleCPPTypeToCSharpType();
}
if (typ == null)
{
throw new InvalidOperationException("Don't know how to deal with type '" + (r as RegularDecl).Type + "'.");
}
return(typ);
}
var t = r as TemplateInfo;
if (t.TemplateName != "vector")
{
throw new NotImplementedException("Don't know how to deal with anything but a vector right now!");
}
var argTrans = TranslateToCSharp(t.Arguments[0]);
return(argTrans + "[]");
}
public class AccessSpecDecl : Decl { internal AccessSpecDecl(IDecl parent) : base(DeclKind.AccessSpec, parent)
{
}
public class NamespaceAliasDecl : NamedDecl { internal NamespaceAliasDecl(IDecl parent) : base(DeclKind.NamespaceAlias, parent)
{
}
internal NamedDecl(DeclKind kind, IDecl parent) : base(kind, parent)
{
}
internal LabelDecl(IDecl parent)
: base(DeclKind.Label, parent)
{
}
/// <summary>
/// Add import statements for given declaration.
/// </summary>
public static void WriteImports(TypeDecl decl, List <IDecl> declarations, CodeWriter writer)
{
// Always import attr module
writer.AppendLine("import attr");
// Instant is generated as Union[dt.datetime, dc.Instant] thus dt import is required
if (decl.Elements.Any(e => e.Value != null && (e.Value.Type == ValueParamType.Instant ||
e.Value.Type == ValueParamType.NullableInstant)))
{
writer.AppendLine("import datetime as dt");
}
// If type is abstract - ABC import is needed
if (decl.Kind == TypeKind.Abstract)
{
writer.AppendLine("from abc import ABC");
}
// Check if ObjectId is used
bool hasObjectId = decl.Elements.Any(e => e.Value != null &&
(e.Value.Type == ValueParamType.TemporalId ||
e.Value.Type == ValueParamType.NullableTemporalId));
if (hasObjectId)
{
writer.AppendLine("from bson import ObjectId");
}
// Check imports from typing
var typingImports = new List <string>();
// Python 3.8
// if (decl.Keys.Any() || decl.Kind == TypeKind.Final)
// typingImports.Add("final");
if (decl.Elements.Any(e => e.Vector == YesNo.Y))
{
typingImports.Add("List");
}
if (typingImports.Any())
{
var items = string.Join(", ", typingImports);
writer.AppendLine($"from typing import {items}");
}
bool insideDc = PyExtensions.GetPackage(decl) == "datacentric";
List <string> packagesToImport = new List <string>();
List <string> individualImports = new List <string>();
// Import parent class package as its namespace, or if inside the same package,
// import individual class instead
if (decl.Inherit != null)
{
if (PyExtensions.IsPackageEquals(decl, decl.Inherit))
{
IDecl parentDecl = declarations.FindByKey(decl.Inherit);
individualImports.Add($"from {parentDecl.Category} import {decl.Inherit.Name}");
}
else
{
packagesToImport.Add(PyExtensions.GetPackage(decl.Inherit));
}
}
// Import datacentric package as dc, or if inside datacentric,
// import individual classes instead
else if (decl.IsRecord)
{
if (insideDc)
{
individualImports.Add("from datacentric.storage.record import Record");
}
else
{
packagesToImport.Add("datacentric");
}
}
// First child class of Data
else
{
if (insideDc)
{
individualImports.Add("from datacentric.storage.data import Data");
}
else
{
packagesToImport.Add("datacentric");
}
}
foreach (var data in decl.Elements.Where(d => d.Data != null).Select(d => d.Data))
{
if (PyExtensions.IsPackageEquals(decl, data))
{
IDecl dataDecl = declarations.FindByKey(data);
individualImports.Add($"from {dataDecl.Category} import {data.Name}");
}
else
{
packagesToImport.Add(PyExtensions.GetPackage(data));
}
}
foreach (var enumElement in decl.Elements.Where(d => d.Enum != null).Select(d => d.Enum))
{
if (PyExtensions.IsPackageEquals(decl, enumElement))
{
IDecl enumDecl = declarations.FindByKey(enumElement);
individualImports.Add($"from {enumDecl.Category} import {enumElement.Name}");
}
else
{
packagesToImport.Add(PyExtensions.GetPackage(enumElement));
}
}
foreach (var package in packagesToImport.Distinct())
{
writer.AppendLine($"import {package} as {PyExtensions.GetAlias(package)}");
}
foreach (var import in individualImports.Distinct())
{
writer.AppendLine(import);
}
}
public class FriendDecl : Decl { internal FriendDecl(IDecl parent) : base(DeclKind.Friend, parent)
{
}
/// <summary>
/// Translate the exploded guy into a C# declaration
/// </summary>
/// <param name="r"></param>
/// <returns></returns>
internal static string TranslateToCSharp(IDecl r)
{
if (r is RegularDecl)
{
var typ = (r as RegularDecl).Type;
typ = TypeDefTranslator.ResolveTypedef(typ);
if (typ == "string")
{
throw new NotImplementedException("Unable to translate the C++ type of string");
}
var clsInfo = ROOTNET.NTClass.GetClass(typ);
if (clsInfo != null)
{
if (!clsInfo.IsShellTClass())
typ = "ROOTNET.Interface.N" + typ;
else
typ = typ.SanitizedName();
}
else
{
typ = typ.SimpleCPPTypeToCSharpType();
}
if (typ == null)
throw new InvalidOperationException("Don't know how to deal with type '" + (r as RegularDecl).Type + "'.");
return typ;
}
var t = r as TemplateInfo;
if (t.TemplateName != "vector")
{
throw new NotImplementedException("Don't know how to deal with anything but a vector right now!");
}
var argTrans = TranslateToCSharp(t.Arguments[0]);
return argTrans + "[]";
}
public class ObjCCategoryDecl : ObjCContainerDecl { internal ObjCCategoryDecl(IDecl parent) : base(DeclKind.ObjCCategory, parent)
{
}
public class PragmaDetectMismatchDecl : Decl { internal PragmaDetectMismatchDecl(IDecl parent) : base(DeclKind.PragmaDetectMismatch, parent)
{
}
public class StaticAssertDecl : Decl { internal StaticAssertDecl(IDecl parent) : base(DeclKind.StaticAssert, parent)
{
}
public class PragmaCommentDecl : Decl { internal PragmaCommentDecl(IDecl parent) : base(DeclKind.PragmaComment, parent)
{
}
public class ObjCPropertyImplDecl : Decl { internal ObjCPropertyImplDecl(IDecl parent) : base(DeclKind.ObjCPropertyImpl, parent)
{
}
public class OMPThreadPrivateDecl : Decl { internal OMPThreadPrivateDecl(IDecl parent) : base(DeclKind.OMPThreadPrivate, parent)
{
}
public class ObjCCompatibleAliasDecl : NamedDecl { internal ObjCCompatibleAliasDecl(IDecl parent) : base(DeclKind.ObjCCompatibleAlias, parent)
{
}
public class OMPDeclareReductionDecl : ValueDecl { internal OMPDeclareReductionDecl(IDecl parent) : base(DeclKind.OMPDeclareReduction, parent)
{
}
public class ObjCContainerDecl : NamedDecl { internal ObjCContainerDecl(DeclKind kind, IDecl parent) : base(kind, parent)
{
}
public class IndirectFieldDecl : ValueDecl { internal IndirectFieldDecl(IDecl parent) : base(DeclKind.IndirectField, parent)
{
}
public class VarTemplatePartialSpecializationDecl : VarTemplateSpecializationDecl { internal VarTemplatePartialSpecializationDecl(IDecl parent) : base(DeclKind.VarTemplatePartialSpecialization, parent)
{
}
public class EnumConstantDecl : ValueDecl { internal EnumConstantDecl(IDecl parent) : base(DeclKind.EnumConstant, parent)
{
}
public class TranslationUnitDecl : Decl { internal TranslationUnitDecl(IDecl parent) : base(DeclKind.TranslationUnit, parent)
{
}
public class UnresolvedUsingValueDecl : ValueDecl { internal UnresolvedUsingValueDecl(IDecl parent) : base(DeclKind.UnresolvedUsingValue, parent)
{
}
public TemplateInfo(string templateName, IDecl[] args)
{
TemplateName = templateName;
Arguments = args;
}
public class FriendTemplateDecl : Decl { internal FriendTemplateDecl(IDecl parent) : base(DeclKind.FriendTemplate, parent)
{
}
int Compare(IDecl decl1, IDecl decl2)
{
if (decl1 is LocalDecl && decl2 is LocalDecl)
{
LocalDecl aDecl1 = (LocalDecl)decl1;
LocalDecl aDecl2 = (LocalDecl)decl2;
if (aDecl1.ParentMethod != aDecl2.ParentMethod)
return aDecl1.ParentMethod.GetHashCode().CompareTo(aDecl2.ParentMethod.GetHashCode());//Here, I assume that the hash codes will always be diffrent.
}
return decl1.Name.CompareTo(decl2.Name);
}
public class ImportDecl : Decl { internal ImportDecl(IDecl parent) : base(DeclKind.Import, parent)
{
}
public IDecl CreateDecl(DeclKind kind, IDecl parent)
{
Decl ret;
switch (kind)
{
case DeclKind.AccessSpec: ret = new AccessSpecDecl(parent); break;
case DeclKind.Block: ret = new BlockDecl(parent); break;
case DeclKind.Captured: ret = new CapturedDecl(parent); break;
case DeclKind.ClassScopeFunctionSpecialization: ret = new ClassScopeFunctionSpecializationDecl(parent); break;
case DeclKind.Empty: ret = new EmptyDecl(parent); break;
case DeclKind.Export: ret = new ExportDecl(parent); break;
case DeclKind.ExternCContext: ret = new ExternCContextDecl(parent); break;
case DeclKind.FileScopeAsm: ret = new FileScopeAsmDecl(parent); break;
case DeclKind.Friend: ret = new FriendDecl(parent); break;
case DeclKind.FriendTemplate: ret = new FriendTemplateDecl(parent); break;
case DeclKind.Import: ret = new ImportDecl(parent); break;
case DeclKind.LinkageSpec: ret = new LinkageSpecDecl(parent); break;
case DeclKind.Label: ret = new LabelDecl(parent); break;
case DeclKind.Namespace: ret = new NamespaceDecl(parent); break;
case DeclKind.NamespaceAlias: ret = new NamespaceAliasDecl(parent); break;
case DeclKind.ObjCCompatibleAlias: ret = new ObjCCompatibleAliasDecl(parent); break;
case DeclKind.ObjCCategory: ret = new ObjCCategoryDecl(parent); break;
case DeclKind.ObjCCategoryImpl: ret = new ObjCCategoryImplDecl(parent); break;
case DeclKind.ObjCImplementation: ret = new ObjCImplementationDecl(parent); break;
case DeclKind.ObjCInterface: ret = new ObjCInterfaceDecl(parent); break;
case DeclKind.ObjCProtocol: ret = new ObjCProtocolDecl(parent); break;
case DeclKind.ObjCMethod: ret = new ObjCMethodDecl(parent); break;
case DeclKind.ObjCProperty: ret = new ObjCPropertyDecl(parent); break;
case DeclKind.BuiltinTemplate: ret = new BuiltinTemplateDecl(parent); break;
case DeclKind.ClassTemplate: ret = new ClassTemplateDecl(parent); break;
case DeclKind.FunctionTemplate: ret = new FunctionTemplateDecl(parent); break;
case DeclKind.TypeAliasTemplate: ret = new TypeAliasTemplateDecl(parent); break;
case DeclKind.VarTemplate: ret = new VarTemplateDecl(parent); break;
case DeclKind.TemplateTemplateParm: ret = new TemplateTemplateParmDecl(parent); break;
case DeclKind.Enum: ret = new EnumDecl(parent); break;
case DeclKind.Record: ret = new RecordDecl(parent); break;
case DeclKind.CXXRecord: ret = new CXXRecordDecl(parent); break;
case DeclKind.ClassTemplateSpecialization: ret = new ClassTemplateSpecializationDecl(parent); break;
case DeclKind.ClassTemplatePartialSpecialization: ret = new ClassTemplatePartialSpecializationDecl(parent); break;
case DeclKind.TemplateTypeParm: ret = new TemplateTypeParmDecl(parent); break;
case DeclKind.ObjCTypeParam: ret = new ObjCTypeParamDecl(parent); break;
case DeclKind.TypeAlias: ret = new TypeAliasDecl(parent); break;
case DeclKind.Typedef: ret = new TypedefDecl(parent); break;
case DeclKind.UnresolvedUsingTypename: ret = new UnresolvedUsingTypenameDecl(parent); break;
case DeclKind.Using: ret = new UsingDecl(parent); break;
case DeclKind.UsingDirective: ret = new UsingDirectiveDecl(parent); break;
case DeclKind.UsingPack: ret = new UsingPackDecl(parent); break;
case DeclKind.UsingShadow: ret = new UsingShadowDecl(parent); break;
case DeclKind.ConstructorUsingShadow: ret = new ConstructorUsingShadowDecl(parent); break;
case DeclKind.Binding: ret = new BindingDecl(parent); break;
case DeclKind.Field: ret = new FieldDecl(parent); break;
case DeclKind.ObjCAtDefsField: ret = new ObjCAtDefsFieldDecl(parent); break;
case DeclKind.ObjCIvar: ret = new ObjCIvarDecl(parent); break;
case DeclKind.Function: ret = new FunctionDecl(parent); break;
case DeclKind.CXXDeductionGuide: ret = new CXXDeductionGuideDecl(parent); break;
case DeclKind.CXXMethod: ret = new CXXMethodDecl(parent); break;
case DeclKind.CXXConstructor: ret = new CXXConstructorDecl(parent); break;
case DeclKind.CXXConversion: ret = new CXXConversionDecl(parent); break;
case DeclKind.CXXDestructor: ret = new CXXDestructorDecl(parent); break;
case DeclKind.MSProperty: ret = new MSPropertyDecl(parent); break;
case DeclKind.NonTypeTemplateParm: ret = new NonTypeTemplateParmDecl(parent); break;
case DeclKind.Var: ret = new VarDecl(parent); break;
case DeclKind.Decomposition: ret = new DecompositionDecl(parent); break;
case DeclKind.ImplicitParam: ret = new ImplicitParamDecl(parent); break;
case DeclKind.OMPCapturedExpr: ret = new OMPCapturedExprDecl(parent); break;
case DeclKind.ParmVar: ret = new ParmVarDecl(parent); break;
case DeclKind.VarTemplateSpecialization: ret = new VarTemplateSpecializationDecl(parent); break;
case DeclKind.VarTemplatePartialSpecialization: ret = new VarTemplatePartialSpecializationDecl(parent); break;
case DeclKind.EnumConstant: ret = new EnumConstantDecl(parent); break;
case DeclKind.IndirectField: ret = new IndirectFieldDecl(parent); break;
case DeclKind.OMPDeclareReduction: ret = new OMPDeclareReductionDecl(parent); break;
case DeclKind.UnresolvedUsingValue: ret = new UnresolvedUsingValueDecl(parent); break;
case DeclKind.OMPThreadPrivate: ret = new OMPThreadPrivateDecl(parent); break;
case DeclKind.ObjCPropertyImpl: ret = new ObjCPropertyImplDecl(parent); break;
case DeclKind.PragmaComment: ret = new PragmaCommentDecl(parent); break;
case DeclKind.PragmaDetectMismatch: ret = new PragmaDetectMismatchDecl(parent); break;
case DeclKind.StaticAssert: ret = new StaticAssertDecl(parent); break;
case DeclKind.TranslationUnit: ret = new TranslationUnitDecl(parent); break;
default: throw new NotImplementedException();
}
if (parent == null)
{
Decls.Add(ret);
}
return(ret);
}
public class LinkageSpecDecl : Decl { internal LinkageSpecDecl(IDecl parent) : base(DeclKind.LinkageSpec, parent)
{
}
