protected override void PreObjectWrite(ICSharpFormatter formatter)
{
foreach (var attr in Attributes)
{
formatter.WriteLine($"[{attr}]");
}
}
protected override void WriteObjectFields(ICSharpFormatter formatter, bool comment)
{
if (ClosureType != ClosureType.Interface && !DisableInterfaceFieldImplementation)
{
FieldRewriteSeed = new Dictionary <string, int>();
ImplementInterface(formatter, comment);
}
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
string genericTypes = string.Join(", ", GenericTypes.Select(cls => cls.Name));
if (GenericTypes.Count() > 0)
{
genericTypes = "<" + genericTypes + ">";
}
base.Write(formatter);
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (ReferencedObject != null)
{
ReferencedObject.Write(formatter, comment);
}
else
{
base.Write(formatter, comment);
}
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (Alias != null)
{
//Alias.Write(formatter);
}
else
{
base.Write(formatter, comment);
}
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (comment)
{
Comment?.Write(formatter);
}
string @enum = string.Join(",\r\n", Values.Select(v => $"{v.Key} = {v.Value}"));
formatter.WriteLine($"{(Access != AccessSpecifier.Private ? Access.ToString().ToLower() + " " : "")} enum {Name}{{");
formatter.WriteLine(@enum);
formatter.WriteLine($"}}");
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (comment)
{
if (Comment != null)
{
Comment.Write(formatter);
}
}
foreach (var attr in Attributes)
{
formatter.WriteLine($"[{attr}]");
}
formatter.WriteLine($"{((Closure.ClosureType != ClosureType.Interface && Closure.ClosureType != ClosureType.AnonymousInterface && Access != AccessSpecifier.Private) ? Access.ToString().ToLower() + " " : "")}{(Closure.ClosureType != ClosureType.Interface && Closure.ClosureType != ClosureType.AnonymousInterface ? /*"extern "*/"virtual " : "")}{(Static ? /*"static "*/"" : "")}{(Abstract ? "abstract " : "")}{Type} {Name.FormatCSharpName()} {{ {(GetSpecifier != AccessSpecifier.Public ? GetSpecifier.ToString().ToLower() + " " : "")}get; {(SetSpecifier != AccessSpecifier.Public ? SetSpecifier.ToString().ToLower() + " " : "")}set; }}");
}
protected override void WriteObjectConstraint(ICSharpFormatter formatter)
{
string baseClasses = null;
if (!DisableBaseClassImplementation)
{
baseClasses = string.Join(", ", Extends.Concat(Implements).ToList().ConvertAll(cls => cls.Name));
if (!string.IsNullOrEmpty(baseClasses))
{
baseClasses = " : " + baseClasses;
}
formatter.Write(baseClasses);
}
base.WriteObjectConstraint(formatter);
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (comment)
{
Comment?.Write(formatter);
}
foreach (var attr in Attributes)
{
formatter.WriteLine($"[{attr}]");
}
formatter.Write($"{Access.ToString().ToLower()}{(Static ? " static" : "")}{(Readonly ? " readonly" : "")} {Type} {Name}{(InitialValue != null ? $" = {InitialValue}" : "")}");
if (Closure.ClosureType != ClosureType.Argument)
{
formatter.WriteLine(";");
}
}
public static void Format(this string comment, ICSharpFormatter formatter)
{
string[] split = comment.Split(new char[] { '\n' });
int minLeftSpace = split.Min(v => CountLeftSpace(v));
for (int i = 0; i < split.Length; i++)
{
if ((i == 0 || i == split.Length - 1) && string.IsNullOrEmpty(split[i].Trim()))
{
continue;
}
split[i] = split[i].Substring(minLeftSpace).TrimEnd();
formatter.WriteLine($"///{split[i]}");
// formatter.WriteLine($"///<para>{split[i]}</para>");
}
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (Alias.Name != Name)
{
string g = "";
if (GenericTypes.Count() > 0)
{
g = "<" + string.Join(", ", GenericTypes.Select(gg => gg.ToString())) + ">";
}
formatter.WriteLine($"public class {Name}{g} : TypeAlias");
formatter.WriteLine($"{{");
formatter.WriteLine($"public {Name}({Alias.Name} value) {{ Value = value; }}");
formatter.WriteLine($"public static implicit operator {Name}{g}({Alias.Name} value){{ return new {Name}{g}(value); }}");
formatter.WriteLine($"}}");
}
//base.Write(formatter, comment);
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (Summary != null || Return != null || (Params != null && Params.Count > 0))
{
formatter.WriteLine($"");
if (Summary != null)
{
Summary.Write(formatter);
}
foreach (var m in Params)
{
m.Write(formatter);
}
if (Return != null)
{
Return.Write(formatter);
}
}
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (_internalType)
{
return;
}
//for classes with constraint that says any, create a class to inherit from this with all the parameters replaced as object
if (GenericTypes.All(t => {
if (t is GenericType gType)
{
return(gType.Constraints.Any(c => c.Name == "object"));
}
return(false);
}))
{
var newClass = new ConcreteClass(Closure, base.Name, Access, Partial, new Class[] { this });
}
base.Write(formatter, comment);
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (!IsParams)
{
if (Optional)
{
//InitialValue = Type.DefaultValue;
}
base.Write(formatter, comment);
//if (!IsLastParameter)
//{
// formatter.Write(", ");
//}
}
else
{
formatter.Write($"params {Type} {Name}");
}
}
void Implement(ICSharpFormatter formatter, Interface @interface, Property property, bool comment, bool @explicit = false, string rewritePropertyName = null)
{
if (comment)
{
property?.Comment.Write(formatter);
}
if (!@explicit)
{
formatter.WriteLine($"public extern {property.Type} {property.Name} {{ get; set; }}");
}
else
{
if (rewritePropertyName != null)
{
formatter.WriteLine($"[Name(\"{property.Name}\")]");
}
rewritePropertyName = rewritePropertyName ?? $"{@interface.FullName}.{property.Name}";
formatter.WriteLine($"extern {property.Type} {rewritePropertyName} {{ get; set; }}");
}
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (_alreadyDefined)
{
return;
}
//foreach (var @class in Objects.Where(o => {
// if (o is AliasType)
// return true;
// return false;
//}))
//{
// @class.Write(formatter, comment);
//}
if (Comment != null)
{
Comment.Write(formatter, comment);
}
if (WillConvertToStaticClass())
{
formatter.WriteLine($"public class {Name}" + " {");
}
else
{
formatter.WriteLine($"namespace {Name}" + " {");
}
foreach (var @class in Objects.ToList() /*.Where(o=> {
* if (o is AliasType)
* return false;
* return true;
* })*/)
{
@class.Write(formatter, comment);
}
foreach (var @namespace in Childs)
{
@namespace.Write(formatter, comment);
}
formatter.WriteLine("}");
}
void Implement(ICSharpFormatter formatter, Interface @interface, Method method, bool comment, bool @explicit = false, string rewriteMethodName = null)
{
if (comment)
{
method?.Comment.Write(formatter);
}
string @params = string.Join(", ", method.Parameters.ConvertAll(p => p.ToString()));
if (!@explicit)
{
formatter.WriteLine($"public extern {method.Return} {method.Name}({@params})");
}
else
{
if (rewriteMethodName != null)
{
formatter.WriteLine($"[Name(\"{method.Name}\")]");
}
rewriteMethodName = rewriteMethodName ?? $"{@interface.FullName}.{method.Name}";
formatter.WriteLine($"extern {method.Return} {rewriteMethodName}({@params})");
}
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (comment)
{
if (Comment != null)
{
Comment.Write(formatter);
}
}
string @params = string.Join(", ", Parameters.ConvertAll(p => p.ToString()));
string @paramsName = string.Join(", ", Parameters.ConvertAll(p => p.Name));
foreach (var attr in Attributes)
{
formatter.WriteLine($"[{attr}]");
}
if (!IsIndexer)
{
string generics = "";
if (GenericArgs != null && GenericArgs.Count > 0)
{
generics = "<" + string.Join(", ", GenericArgs.ConvertAll(a =>
{
var v = a.ToString(); if (v == "void")
{
v = "undefined";
}
return(v);
})) + ">";
}
var name = Name.Split(new char[] { '<' })[0];
formatter.WriteLine($"{((Closure.ClosureType != ClosureType.Interface && Closure.ClosureType != ClosureType.AnonymousInterface && Access != AccessSpecifier.Private) ? Access.ToString().ToLower() + " " : "")}{(Closure.ClosureType != ClosureType.Interface && Closure.ClosureType != ClosureType.AnonymousInterface &&!IsImplicitConverter && !IsConstructor ? /*"extern "*/"virtual " : "")}{(IsImplicitConverter ? "static " : "")}{(Abstract ? "abstract " : "")}{(Return != null ? Return.ToString() + " " : "")}{name.FormatCSharpName()}{generics}({@params}){( Body != null ? Body : Closure.ClosureType != ClosureType.Interface && Closure.ClosureType != ClosureType.AnonymousInterface && !IsImplicitConverter ? ((Return?.Name??"void") != "void" && !IsConstructor ? $" => default({Return});" : ((IsConstructor && Closure is Class && (Closure as Class).Extends.Any(m=> (m is Class) && (m as Class).Methods.Any(mm => mm.IsConstructor)) && false ? $" : base({@paramsName})" : "") + "{ }")) : ";")}");
}
else
{
formatter.WriteLine($"{((Closure.ClosureType != ClosureType.Interface && Closure.ClosureType != ClosureType.AnonymousInterface && Access != AccessSpecifier.Private) ? Access.ToString().ToLower() + " " : "")}{(Closure.ClosureType != ClosureType.Interface && Closure.ClosureType != ClosureType.AnonymousInterface ? /*"extern "*/"virtual " : "")}{(Static ? /*"static "*/"" : "")}{(Abstract ? "abstract " : "")}{Return} this[{@params}]{{ get; set; }}");
}
}
public abstract void Write(ICSharpFormatter formatter, bool comment = true);
protected virtual void PreObjectWrite(ICSharpFormatter formatter)
{
}
protected virtual void WriteObjectConstraint(ICSharpFormatter formatter)
{
}
protected virtual void PostWrite(ICSharpFormatter formatter)
{
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
formatter.WriteLine($"using {NameSpace};");
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
formatter.Write($"delegate {Return} {Name}");
base.Write(formatter, comment);
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
formatter.Write($"{Name}");
}
void ImplementInterface(ICSharpFormatter formatter, bool comment)
{
if (Name == "ComponentConfigClass")
{
}
this.interfaces = null;
this.properties = null;
this.methods = null;
var interfaces = GetInterfaces();
var properties = GetProperties();
var methods = GetMethods();
var directInterfaces = interfaces.Where(m => m.Key.Equals(this)).SelectMany(m => m.Value).ToList();
var allInterfaces = directInterfaces.Concat(directInterfaces.SelectMany(it => it.GetInterfaces().SelectMany(itt => itt.Value))).ToList();
{
Dictionary <Interface, List <Property> > explicitlyImplementedProperties = new Dictionary <Interface, List <Property> >();
List <Property> implementedProperties = new List <Property>();
implementedProperties.AddRange(Properties);
List <string> implementedPropertyNames = new List <string>();
implementedPropertyNames.AddRange(Properties.Select(m => m.Name));
List <string> implementedExplicitInterfaceProperties = new List <string>();
var categorizedProperties = properties.Where(m => m.Key is Interface && allInterfaces.Any(mm => mm.Equals(m.Key)));
foreach (var cp in categorizedProperties)
{
Interface @interface = cp.Key as Interface;
IEnumerable <Property> interfaceProperties = cp.Value;
if (!explicitlyImplementedProperties.ContainsKey(@interface))
{
explicitlyImplementedProperties[@interface] = new List <Property>();
}
foreach (var property in interfaceProperties)
{
if (!implementedProperties.Any(m => m.Equals(property)))
{
bool explicitImpement = implementedPropertyNames.Any(nm => property.Name.Equals(nm));
string rewritePropertyName = null;
if (explicitImpement)
{
if (explicitlyImplementedProperties[@interface].Any(p => p.Equals(property)))
{
continue;
}
if (implementedExplicitInterfaceProperties.Contains($"{@interface.FullName}.{property.Name}"))
{
rewritePropertyName = $"{property.Name}{GetFieldRewriteSeed(property.Name)}";
}
}
if (explicitImpement && DisableBaseClassImplementation) //skip explicit implementation
{
continue;
}
Implement(formatter, @interface, property, comment, explicitImpement, rewritePropertyName);
if (explicitImpement)
{
explicitlyImplementedProperties[@interface].Add(property);
}
else
{
implementedProperties.Add(property);
}
if (rewritePropertyName != null)
{
implementedPropertyNames.Add(rewritePropertyName);
}
else
{
implementedPropertyNames.Add(property.Name);
}
if (explicitImpement)
{
implementedExplicitInterfaceProperties.Add($"{@interface.FullName}.{property.Name}");
if (rewritePropertyName != null)
{
implementedExplicitInterfaceProperties.Add(rewritePropertyName);
}
}
}
}
}
}
{
Dictionary <Interface, List <Method> > explicitlyImplementedMethods = new Dictionary <Interface, List <Method> >();
List <Method> implementedMethods = new List <Method>();
implementedMethods.AddRange(Methods);
List <string> implementedMethodNames = new List <string>();
implementedMethodNames.AddRange(Methods.Select(m => m.Name));
List <string> implementedExplicitInterfaceMethods = new List <string>();
var categorizedMethods = methods.Where(m => m.Key is Interface && allInterfaces.Any(mm => mm.Equals(m.Key)));
foreach (var cp in categorizedMethods)
{
Interface @interface = cp.Key as Interface;
IEnumerable <Method> interfaceMethods = cp.Value;
if (!explicitlyImplementedMethods.ContainsKey(@interface))
{
explicitlyImplementedMethods[@interface] = new List <Method>();
}
foreach (var method in interfaceMethods)
{
if (!implementedMethods.Any(m => m.Equals(method)))
{
bool explicitImpement = implementedMethodNames.Any(nm => method.Name.Equals(nm));
string rewriteMethodName = null;
if (explicitImpement)
{
if (explicitlyImplementedMethods[@interface].Any(p => p.Equals(method)))
{
continue;
}
if (implementedExplicitInterfaceMethods.Contains($"{@interface.FullName}.{method.Name}"))
{
rewriteMethodName = $"{method.Name}{GetFieldRewriteSeed(method.Name)}";
}
}
if (explicitImpement && DisableBaseClassImplementation) //skip explicit implementation
{
continue;
}
Implement(formatter, @interface, method, comment, explicitImpement, rewriteMethodName);
if (explicitImpement)
{
explicitlyImplementedMethods[@interface].Add(method);
}
else
{
implementedMethods.Add(method);
}
if (rewriteMethodName != null)
{
implementedMethodNames.Add(rewriteMethodName);
}
else
{
implementedMethodNames.Add(method.Name);
}
if (explicitImpement)
{
implementedExplicitInterfaceMethods.Add($"{@interface.FullName}.{method.Name}");
if (rewriteMethodName != null)
{
implementedExplicitInterfaceMethods.Add(rewriteMethodName);
}
}
}
}
}
}
}
protected virtual void WriteObjectFields(ICSharpFormatter formatter, bool comment)
{
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
formatter.WriteLine($"public static {Type} {Name.Trim(new char[] { '"' }).FormatCSharpName()} = {Name};");
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
formatter.WriteLine($"///<param name=\"{Name}\">");
Message.Format(formatter);
formatter.WriteLine($"///</param>");
}
public override void Write(ICSharpFormatter formatter, bool comment = true)
{
if (comment)
{
if (Comment != null)
{
Comment.Write(formatter);
}
}
PreObjectWrite(formatter);
formatter.Write(Definition);
WriteObjectConstraint(formatter);
formatter.WriteLine("");
formatter.WriteLine("{");
foreach (var m in InnerObjects.Distinct())
{
m.Write(formatter, comment);
}
List <ICSharpSyntax> generatedFields = new List <ICSharpSyntax>();
List <string> generatedNames = new List <string>();
int ix = 1;
foreach (var m in Variables)
{
if (!generatedFields.Any(f => f.Equals(m)))
{
string originalName = m.Name;
string name = m.Name;
if (generatedNames.Contains(name))
{
//name += ix++;
//m.Attributes.Add($"Name(\"{originalName}\")");
//m.Name = name;
}
m.Write(formatter, comment);
generatedNames.Add(name);
generatedFields.Add(m);
}
}
ix = 1;
foreach (var property in Properties)
{
if (!generatedFields.Any(f => f.Equals(property)))
{
string originalName = property.Name;
string name = property.Name;
if (generatedNames.Contains(name))
{
//name += ix++;
//property.Attributes.Add($"Name(\"{originalName}\")");
//property.Name = name;
}
property.Write(formatter, comment);
generatedNames.Add(name);
generatedFields.Add(property);
}
}
ix = 1;
foreach (var m in Methods)
{
if (!generatedFields.Any(f => f.Equals(m)))
{
string originalName = m.Name;
string name = m.Name;
if (generatedNames.Contains(name) && !m.IsConstructor)
{
//name += ix++;
//m.Attributes.Add($"Name(\"{originalName}\")");
//m.Name = name;
}
m.Write(formatter, comment);
generatedNames.Add(name);
generatedFields.Add(m);
}
}
WriteObjectFields(formatter, comment);
formatter.WriteLine("}");
}
