public object RecreateInterfaceProxy(SerializationInfo info, StreamingContext context)
{
object proxy = null;
GeneratorContext genContext = new GeneratorContext();
foreach(object mixin in _mixins)
{
genContext.AddMixinInstance(mixin);
}
InterfaceProxyGenerator gen = new InterfaceProxyGenerator( _scope, genContext );
object target = info.GetValue("__target", typeof(object));
if (_mixins.Length == 0)
{
Type proxy_type = gen.GenerateCode( _interfaces, target.GetType());
proxy = Activator.CreateInstance( proxy_type, new object[] { _interceptor, target } );
}
else
{
Type proxy_type = gen.GenerateCode( _interfaces, target.GetType() );
proxy = Activator.CreateInstance( proxy_type, new object[] { _interceptor, target, genContext.MixinsAsArray() } );
}
return proxy;
}
protected override void GeneratePropertySet (GeneratorContext ctx, CodeExpression var, PropertyDescriptor prop)
{
if (prop.Name == "Alpha" && Alpha == -1)
return;
else
base.GeneratePropertySet (ctx, var, prop);
}
public void TwoMixins()
{
GeneratorContext context = new GeneratorContext();
SimpleMixin mixin1 = new SimpleMixin();
OtherMixin mixin2 = new OtherMixin();
context.AddMixinInstance( mixin1 );
context.AddMixinInstance( mixin2 );
AssertInvocationInterceptor interceptor = new AssertInvocationInterceptor();
object proxy = _generator.CreateCustomClassProxy(
typeof(SimpleClass), interceptor, context );
Assert.IsFalse( interceptor.Invoked );
Assert.IsNotNull(proxy);
Assert.IsTrue( typeof(SimpleClass).IsAssignableFrom( proxy.GetType() ) );
ISimpleMixin mixin = proxy as ISimpleMixin;
Assert.IsNotNull(mixin);
Assert.AreEqual(1, mixin.DoSomething());
Assert.IsTrue( interceptor.Invoked );
Assert.AreSame( proxy, interceptor.proxy );
Assert.AreSame( mixin1, interceptor.mixin );
IOtherMixin other = proxy as IOtherMixin;
Assert.IsNotNull(other);
Assert.AreEqual(3, other.Sum(1,2));
Assert.IsTrue( interceptor.Invoked );
Assert.AreSame( proxy, interceptor.proxy );
Assert.AreSame( mixin2, interceptor.mixin );
}
internal protected override CodeExpression GenerateObjectCreation (GeneratorContext ctx)
{
return new CodeObjectCreateExpression (
ClassDescriptor.WrappedTypeName.ToGlobalTypeRef (),
new CodePrimitiveExpression (null),
new CodePrimitiveExpression (null)
);
}
public void Run(ServiceDefinition definition)
{
var context = new GeneratorContext();
context.Definition = definition;
context.Root = definition.Root;
this.WriteEverything(context);
text.Flush();
}
internal protected override CodeExpression GenerateObjectCreation (GeneratorContext ctx)
{
if (textCombo) {
return new CodeMethodInvokeExpression (
new CodeTypeReferenceExpression (new CodeTypeReference ("Gtk.ComboBox", CodeTypeReferenceOptions.GlobalReference)),
"NewText"
);
} else
return base.GenerateObjectCreation (ctx);
}
protected internal override CodeExpression GenerateObjectCreation(GeneratorContext ctx)
{
if (IsTextCombo) {
return new CodeMethodInvokeExpression (
new CodeTypeReferenceExpression ("Gtk.ComboBoxEntry"),
"NewText"
);
} else
return base.GenerateObjectCreation (ctx);
}
public void CreateCustomProxy()
{
GeneratorContext context = new GeneratorContext(
new EnhanceTypeDelegate(EnhanceType),
new ScreenInterfacesDelegate(ScreenInterfaces));
object proxy = m_generator.CreateCustomProxy(
typeof (IMyInterface),
new StandardInvocationHandler(new MyInterfaceImpl()), context);
Assert.IsTrue( m_enhanceInvoked );
Assert.IsTrue( m_screenInvoked );
}
protected override void GeneratePropertySet (GeneratorContext ctx, CodeExpression var, PropertyDescriptor prop)
{
if (prop.Name == "Group") {
CodeExpression groupExp = GroupManager.GenerateGroupExpression (ctx, (Gtk.Widget) Wrapped);
ctx.Statements.Add (
new CodeAssignStatement (
new CodePropertyReferenceExpression (var, "Group"),
groupExp)
);
}
else
base.GeneratePropertySet (ctx, var, prop);
}
public static void Main(string[] args)
{
try
{
List<object> instances = new List<object>();
GeneratorContext context = new GeneratorContext();
Generator generator = new Generator(instances, context);
generator.Execute();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public void GenerateBuildCode(GeneratorContext ctx, CodeVariableReferenceExpression uiManager)
{
StringBuilder sb = new StringBuilder ();
sb.Append ("<ui>");
GenerateUiString (sb);
sb.Append ("</ui>");
CodeMethodInvokeExpression exp = new CodeMethodInvokeExpression (
uiManager,
"AddUiFromString",
new CodePrimitiveExpression (sb.ToString ())
);
ctx.Statements.Add (exp);
}
protected override void GenerateChildBuildCode (GeneratorContext ctx, CodeExpression parentVar, Widget wrapper)
{
if (wrapper.Wrapped == expander.LabelWidget) {
CodeExpression var = ctx.GenerateNewInstanceCode (wrapper);
CodeAssignStatement assign = new CodeAssignStatement (
new CodePropertyReferenceExpression (
parentVar,
"LabelWidget"
),
var
);
ctx.Statements.Add (assign);
} else
base.GenerateChildBuildCode (ctx, parentVar, wrapper);
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
MainOptions opts = new MainOptions();
opts.ProcessArgs(args);
if (args.Length == 0 || args[0].StartsWith("-"))
{
ShowUsage();
}
Console.WriteLine("Processing {0} {1}", args[0], opts.verbose);
IGenerator generator = null;
if (args[0] == "controller")
{
generator = new NewController();
}
else if (args[0] == "project")
{
generator = new NewProject();
}
else
{
Console.Error.WriteLine("Not supported");
return;
}
Configure(generator, args);
string workingDir = AppDomain.CurrentDomain.BaseDirectory;
string templateDir = @"C:\dev\DotNet\castle\svn\trunk\MonoRail\NewGenerator\GeneratorTemplates\";
GeneratorContext context = new GeneratorContext(workingDir, templateDir);
ITemplateEngine engine = new NVelocityTemplateEngine(templateDir);
if (engine is ISupportInitialize)
{
((ISupportInitialize)engine).BeginInit();
}
generator.Generate(context, new DefaultGeneratorService(context, engine));
}
protected override void GenerateChildBuildCode (GeneratorContext ctx, CodeExpression parentVar, Widget wrapper)
{
if (!HasLabel) {
// CheckButton generates a label by default. Remove it if it is not required.
ctx.Statements.Add (
new CodeMethodInvokeExpression (
parentVar,
"Remove",
new CodePropertyReferenceExpression (
parentVar,
"Child"
)
)
);
}
base.GenerateChildBuildCode (ctx, parentVar, wrapper);
}
internal protected override void GenerateBuildCode (GeneratorContext ctx, CodeExpression var)
{
if (Text.Length > 0) {
ctx.Statements.Add (
new CodeAssignStatement (
new CodePropertyReferenceExpression (
new CodePropertyReferenceExpression (
var,
"Buffer"
),
"Text"
),
new CodePrimitiveExpression (Text)
)
);
}
base.GenerateBuildCode (ctx, var);
}
internal protected override void GeneratePostBuildCode (GeneratorContext ctx, CodeExpression var)
{
if (mnem != null) {
Widget targetWidget = GetTopLevel ().FindChild (mnem);
if (targetWidget != null) {
CodeExpression memVar = ctx.WidgetMap.GetWidgetExp (targetWidget);
if (memVar != null) {
ctx.Statements.Add (
new CodeAssignStatement (
new CodePropertyReferenceExpression (
var,
"MnemonicWidget"
),
memVar
)
);
}
}
}
base.GeneratePostBuildCode (ctx, var);
}
public void Execute(object Application, int hwndOwner, ref object[] ContextParams, ref object[] CustomParams,
ref wizardResult retval)
{
DTE dte = (DTE) Application;
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
string workingDir = (string) ContextParams[3];
string templateDir = @"C:\dev\DotNet\castle\svn\trunk\MonoRail\NewGenerator\GeneratorTemplates\";
context = new GeneratorContext(workingDir, templateDir);
//Using NVelocityTemplateEngine. Since we must resolve the lib dir...
templateEngine = new NVelocityTemplateEngine(templateDir);
((ISupportInitialize) templateEngine).BeginInit();
NewProject generator = CreateNewProject(ContextParams);
generator.Generate(context, this);
dte.Solution.Open(generator.SolutionFilePath);
}
public CodeExpression GenerateGroupExpression(GeneratorContext ctx, Action action)
{
// Returns and expression that represents the group to which the radio belongs.
// This expression can be an empty SList, if this is the first radio of the
// group that has been generated, or an SList taken from previously generated
// radios from the same group.
string group = actions [action] as string;
if (group == null)
return new CodePrimitiveExpression (null);
CodeExpression var = null;
foreach (Action a in FindActionsInGroup (group)) {
if (a == action)
continue;
var = ctx.WidgetMap.GetWidgetExp (a);
if (var != null)
break;
}
if (var == null) {
return new CodeObjectCreateExpression (
"GLib.SList",
new CodePropertyReferenceExpression (
new CodeTypeReferenceExpression (typeof(IntPtr)),
"Zero"
)
);
} else {
return new CodePropertyReferenceExpression (
var,
"Group"
);
}
}
internal protected override void GenerateBuildCode (GeneratorContext ctx, CodeExpression var)
{
if (textCombo && Items != null && Items.Length > 0) {
foreach (string str in Items) {
ctx.Statements.Add (new CodeMethodInvokeExpression (
var,
"AppendText",
ctx.GenerateValue (str, typeof(string), true)
));
}
}
base.GenerateBuildCode (ctx, var);
}
/// <summary>
/// Emit the start of an enum declaration for 'oneof' groups, including the 0/None element
/// </summary>
protected override void WriteOneOfEnumHeader(GeneratorContext ctx, OneofDescriptorProto obj, ref object state)
{
ctx.WriteLine().WriteLine($"public enum {ctx.NameNormalizer.GetName(obj)}{OneOfEnumSuffixEnum}").WriteLine("{").Indent().WriteLine("None = 0,");
}
public CSharpMnemonicsTableGenerator(GeneratorContext generatorContext)
{
idConverter = CSharpIdentifierConverter.Create();
this.generatorContext = generatorContext;
}
public virtual Type CreateCustomClassProxy(Type theClass, GeneratorContext context)
{
ClassProxyGenerator generator = new ClassProxyGenerator(_scope, context);
return(generator.GenerateCustomCode(theClass, null));
}
protected override void GeneratePropertySet (GeneratorContext ctx, CodeExpression var, PropertyDescriptor prop)
{
if (prop.Name != "MnemonicWidget")
base.GeneratePropertySet (ctx, var, prop);
}
/// <summary>
/// Write a field
/// </summary>
protected override void WriteField(GeneratorContext ctx, FieldDescriptorProto obj, ref object state, OneOfStub[] oneOfs)
{
var name = ctx.NameNormalizer.GetName(obj);
var tw = ctx.Write($@"[global::ProtoBuf.ProtoMember({obj.Number}");
if (name != obj.Name)
{
tw.Write($@", Name = @""{obj.Name}""");
}
var options = obj.Options?.GetOptions();
if (options?.AsReference == true)
{
tw.Write($@", AsReference = true");
}
if (options?.DynamicType == true)
{
tw.Write($@", DynamicType = true");
}
bool isOptional = obj.label == FieldDescriptorProto.Label.LabelOptional;
bool isRepeated = obj.label == FieldDescriptorProto.Label.LabelRepeated;
OneOfStub oneOf = obj.ShouldSerializeOneofIndex() ? oneOfs?[obj.OneofIndex] : null;
if (oneOf != null && !ctx.OneOfEnums && oneOf.CountTotal == 1)
{
oneOf = null; // not really a one-of, then!
}
bool explicitValues = isOptional && oneOf == null && ctx.Syntax == FileDescriptorProto.SyntaxProto2 &&
obj.type != FieldDescriptorProto.Type.TypeMessage &&
obj.type != FieldDescriptorProto.Type.TypeGroup;
bool suppressDefaultAttribute = !isOptional;
var typeName = GetTypeName(ctx, obj, out var dataFormat, out var isMap);
string defaultValue = GetDefaultValue(ctx, obj, typeName);
if (!string.IsNullOrWhiteSpace(dataFormat))
{
tw.Write($", DataFormat = global::ProtoBuf.DataFormat.{dataFormat}");
}
if (obj.IsPacked(ctx.Syntax))
{
tw.Write($", IsPacked = true");
}
if (obj.label == FieldDescriptorProto.Label.LabelRequired)
{
tw.Write($", IsRequired = true");
}
tw.WriteLine(")]");
if (!isRepeated && !string.IsNullOrWhiteSpace(defaultValue) && !suppressDefaultAttribute)
{
ctx.WriteLine($"[global::System.ComponentModel.DefaultValue({defaultValue})]");
}
WriteOptions(ctx, obj.Options);
if (isRepeated)
{
var mapMsgType = isMap ? ctx.TryFind <DescriptorProto>(obj.TypeName) : null;
if (mapMsgType != null)
{
var keyTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 1),
out var keyDataFormat, out var _);
var valueTypeName = GetTypeName(ctx, mapMsgType.Fields.Single(x => x.Number == 2),
out var valueDataFormat, out var _);
bool first = true;
tw = ctx.Write($"[global::ProtoBuf.ProtoMap");
if (!string.IsNullOrWhiteSpace(keyDataFormat))
{
tw.Write($"{(first ? "(" : ", ")}KeyFormat = global::ProtoBuf.DataFormat.{keyDataFormat}");
first = false;
}
if (!string.IsNullOrWhiteSpace(valueDataFormat))
{
tw.Write($"{(first ? "(" : ", ")}ValueFormat = global::ProtoBuf.DataFormat.{valueDataFormat}");
first = false;
}
tw.WriteLine(first ? "]" : ")]");
if (ctx.Supports(CSharp6))
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} global::System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}> {Escape(name)} {{ get; }} = new global::System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}>();");
}
else
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} global::System.Collections.Generic.Dictionary<{keyTypeName}, {valueTypeName}> {Escape(name)} {{ get; private set; }}");
}
}
else if (UseArray(obj))
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} {typeName}[] {Escape(name)} {{ get; set; }}");
}
else if (ctx.Supports(CSharp6))
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} global::System.Collections.Generic.List<{typeName}> {Escape(name)} {{ get; }} = new global::System.Collections.Generic.List<{typeName}>();");
}
else
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} global::System.Collections.Generic.List<{typeName}> {Escape(name)} {{ get; private set; }}");
}
}
else if (oneOf != null)
{
var defValue = string.IsNullOrWhiteSpace(defaultValue) ? (ctx.Supports(CSharp7_1) ? "default" : $"default({typeName})") : defaultValue;
var fieldName = GetOneOfFieldName(oneOf.OneOf);
var storage = oneOf.GetStorage(obj.type, obj.TypeName);
ctx.WriteLine($"{GetAccess(GetAccess(obj))} {typeName} {Escape(name)}").WriteLine("{").Indent();
switch (obj.type)
{
case FieldDescriptorProto.Type.TypeMessage:
case FieldDescriptorProto.Type.TypeGroup:
case FieldDescriptorProto.Type.TypeEnum:
case FieldDescriptorProto.Type.TypeBytes:
case FieldDescriptorProto.Type.TypeString:
ctx.WriteLine($"get {{ return {fieldName}.Is({obj.Number}) ? (({typeName}){fieldName}.{storage}) : {defValue}; }}");
break;
default:
ctx.WriteLine($"get {{ return {fieldName}.Is({obj.Number}) ? {fieldName}.{storage} : {defValue}; }}");
break;
}
var unionType = oneOf.GetUnionType();
var cast = obj.type == FieldDescriptorProto.Type.TypeEnum ? "(int)" : "";
ctx.WriteLine($"set {{ {fieldName} = new global::ProtoBuf.{unionType}({obj.Number}, {cast}value); }}")
.Outdent().WriteLine("}");
if (ctx.Supports(CSharp6))
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} bool ShouldSerialize{name}() => {fieldName}.Is({obj.Number});")
.WriteLine($"{GetAccess(GetAccess(obj))} void Reset{name}() => global::ProtoBuf.{unionType}.Reset(ref {fieldName}, {obj.Number});");
}
else
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} bool ShouldSerialize{name}()").WriteLine("{").Indent()
.WriteLine($"return {fieldName}.Is({obj.Number});").Outdent().WriteLine("}")
.WriteLine($"{GetAccess(GetAccess(obj))} void Reset{name}()").WriteLine("{").Indent()
.WriteLine($"global::ProtoBuf.{unionType}.Reset(ref {fieldName}, {obj.Number});").Outdent().WriteLine("}");
}
if (oneOf.IsFirst())
{
ctx.WriteLine().WriteLine($"private global::ProtoBuf.{unionType} {fieldName};");
}
}
else if (explicitValues)
{
string fieldName = FieldPrefix + name, fieldType;
bool isRef = false;
switch (obj.type)
{
case FieldDescriptorProto.Type.TypeString:
case FieldDescriptorProto.Type.TypeBytes:
fieldType = typeName;
isRef = true;
break;
default:
fieldType = typeName + "?";
break;
}
ctx.WriteLine($"{GetAccess(GetAccess(obj))} {typeName} {Escape(name)}").WriteLine("{").Indent();
tw = ctx.Write($"get {{ return {fieldName}");
if (!string.IsNullOrWhiteSpace(defaultValue))
{
tw.Write(" ?? ");
tw.Write(defaultValue);
}
else if (!isRef)
{
tw.Write(".GetValueOrDefault()");
}
tw.WriteLine("; }");
ctx.WriteLine($"set {{ {fieldName} = value; }}")
.Outdent().WriteLine("}");
if (ctx.Supports(CSharp6))
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} bool ShouldSerialize{name}() => {fieldName} != null;")
.WriteLine($"{GetAccess(GetAccess(obj))} void Reset{name}() => {fieldName} = null;");
}
else
{
ctx.WriteLine($"{GetAccess(GetAccess(obj))} bool ShouldSerialize{name}()").WriteLine("{").Indent()
.WriteLine($"return {fieldName} != null;").Outdent().WriteLine("}")
.WriteLine($"{GetAccess(GetAccess(obj))} void Reset{name}()").WriteLine("{").Indent()
.WriteLine($"{fieldName} = null;").Outdent().WriteLine("}");
}
ctx.WriteLine($"private {fieldType} {fieldName};");
}
else
{
tw = ctx.Write($"{GetAccess(GetAccess(obj))} {typeName} {Escape(name)} {{ get; set; }}");
if (!string.IsNullOrWhiteSpace(defaultValue) && ctx.Supports(CSharp6))
{
tw.Write($" = {defaultValue};");
}
tw.WriteLine();
}
ctx.WriteLine();
}
public RustInstructionOpCountsGenerator(GeneratorContext generatorContext)
{
idConverter = RustIdentifierConverter.Create();
this.generatorContext = generatorContext;
}
/// <summary>
/// Emit a field-based entry for a 'oneof' groups's enum
/// </summary>
protected override void WriteOneOfEnumValue(GeneratorContext ctx, FieldDescriptorProto field, ref object state)
{
var name = ctx.NameNormalizer.GetName(field);
ctx.WriteLine($"{Escape(name)} = {field.Number}");
}
/// <summary>
/// End a message
/// </summary>
protected override void WriteMessageFooter(GeneratorContext ctx, DescriptorProto message, ref object state)
{
ctx.Outdent().WriteLine("End Class").WriteLine();
}
/// <summary>
/// Emit the end of an enum declaration for 'oneof' groups
/// </summary>
protected override void WriteOneOfEnumFooter(GeneratorContext ctx, OneofDescriptorProto oneof, ref object state)
{
ctx.Outdent().WriteLine("End Enum").WriteLine();
}
/// <summary>
/// Emit the start of an enum declaration for 'oneof' groups, including the 0/None element
/// </summary>
protected override void WriteOneOfEnumHeader(GeneratorContext ctx, OneofDescriptorProto oneof, ref object state)
{
ctx.WriteLine($"Public Enum {Escape(ctx.NameNormalizer.GetName(oneof))}{OneOfEnumSuffixEnum}").Indent().WriteLine("None = 0");
}
/// <summary>
/// End an enum
/// </summary>
protected override void WriteEnumFooter(GeneratorContext ctx, EnumDescriptorProto @enum, ref object state)
{
ctx.Outdent().WriteLine("End Enum").WriteLine();
}
protected override void WriteFile(GeneratorContext ctx, FileDescriptorProto obj)
{
var file = ctx.File;
var ast = new ProtoFile
{
Filename = file.Name,
PackageName = file.Package,
CsNamespace = file.Options?.CsharpNamespace ?? file.Package,
Messages = file
.MessageTypes
.ToArray()
.Select(mt => new ProtoMessage
{
Name = mt.Name,
Fields = mt.Fields.Select(f => new ProtoField()
{
TypeName = f.TypeName,
Name = f.Name,
Number = f.Number,
IsRepeated = f.label == FieldDescriptorProto.Label.LabelRepeated,
OneOfIndex = f.OneofIndex,
Type = f.type,
Object = ctx.TryFind <DescriptorProto>(f.TypeName),
}).ToArray()
})
.ToArray(),
Services = file
.Services
.ToArray()
.Select(
s => new ProtoService
{
Name = s.Name,
Methods = s.Methods.ToArray()
.Select(
(m, i) => new ProtoMethod
{
Index = i,
Name = m.Name,
InputNameRaw = RemovePackageName(m.InputType),
OutputNameRaw = RemovePackageName(m.OutputType),
InputObject = ctx.TryFind <DescriptorProto>(m.InputType),
OutputObject = ctx.TryFind <DescriptorProto>(m.OutputType),
}
)
.ToArray()
}
)
.ToArray()
};
Handlebars.RegisterHelper("StringEquality", (output, options, context, arguments) =>
{
if (arguments.Length != 2)
{
throw new HandlebarsException("{{#StringEquality}} helper must have exactly two arguments");
}
var left = arguments.At <string>(0);
var right = arguments[1] as string;
if (left == right)
{
options.Template(output, context);
}
else
{
options.Inverse(output, context);
}
});
var f = Handlebars.Compile(_template);
var result = f(ast);
ctx.WriteLine(result);
private string GetTypeName(GeneratorContext ctx, FieldDescriptorProto field, out string dataFormat, out bool isMap)
{
dataFormat = "";
isMap = false;
switch (field.type)
{
case FieldDescriptorProto.Type.TypeDouble:
return("double");
case FieldDescriptorProto.Type.TypeFloat:
return("float");
case FieldDescriptorProto.Type.TypeBool:
return("bool");
case FieldDescriptorProto.Type.TypeString:
return("string");
case FieldDescriptorProto.Type.TypeSint32:
dataFormat = nameof(DataFormat.ZigZag);
return("int");
case FieldDescriptorProto.Type.TypeInt32:
return("int");
case FieldDescriptorProto.Type.TypeSfixed32:
dataFormat = nameof(DataFormat.FixedSize);
return("int");
case FieldDescriptorProto.Type.TypeSint64:
dataFormat = nameof(DataFormat.ZigZag);
return("long");
case FieldDescriptorProto.Type.TypeInt64:
return("long");
case FieldDescriptorProto.Type.TypeSfixed64:
dataFormat = nameof(DataFormat.FixedSize);
return("long");
case FieldDescriptorProto.Type.TypeFixed32:
dataFormat = nameof(DataFormat.FixedSize);
return("uint");
case FieldDescriptorProto.Type.TypeUint32:
return("uint");
case FieldDescriptorProto.Type.TypeFixed64:
dataFormat = nameof(DataFormat.FixedSize);
return("ulong");
case FieldDescriptorProto.Type.TypeUint64:
return("ulong");
case FieldDescriptorProto.Type.TypeBytes:
return("byte[]");
case FieldDescriptorProto.Type.TypeEnum:
switch (field.TypeName)
{
case ".bcl.DateTime.DateTimeKind":
return("global::System.DateTimeKind");
}
var enumType = ctx.TryFind <EnumDescriptorProto>(field.TypeName);
return(MakeRelativeName(field, enumType, ctx.NameNormalizer));
case FieldDescriptorProto.Type.TypeGroup:
case FieldDescriptorProto.Type.TypeMessage:
switch (field.TypeName)
{
case WellKnownTypeTimestamp:
dataFormat = "WellKnown";
return("global::System.DateTime?");
case WellKnownTypeDuration:
dataFormat = "WellKnown";
return("global::System.TimeSpan?");
case ".bcl.NetObjectProxy":
return("object");
case ".bcl.DateTime":
return("global::System.DateTime?");
case ".bcl.TimeSpan":
return("global::System.TimeSpan?");
case ".bcl.Decimal":
return("decimal?");
case ".bcl.Guid":
return("global::System.Guid?");
}
var msgType = ctx.TryFind <DescriptorProto>(field.TypeName);
if (field.type == FieldDescriptorProto.Type.TypeGroup)
{
dataFormat = nameof(DataFormat.Group);
}
isMap = msgType?.Options?.MapEntry ?? false;
return(MakeRelativeName(field, msgType, ctx.NameNormalizer));
default:
return(field.TypeName);
}
}
public void MixinForInterfaces()
{
GeneratorContext context = new GeneratorContext();
SimpleMixin mixin_instance = new SimpleMixin();
context.AddMixinInstance( mixin_instance );
AssertInvocationInterceptor interceptor = new AssertInvocationInterceptor();
MyInterfaceImpl target = new MyInterfaceImpl();
object proxy = _generator.CreateCustomProxy(
typeof(IMyInterface), interceptor, target, context );
Assert.IsNotNull(proxy);
Assert.IsTrue( typeof(IMyInterface).IsAssignableFrom( proxy.GetType() ) );
Assert.IsFalse( interceptor.Invoked );
ISimpleMixin mixin = proxy as ISimpleMixin;
Assert.IsNotNull(mixin);
Assert.AreEqual(1, mixin.DoSomething());
Assert.IsTrue( interceptor.Invoked );
Assert.AreSame( proxy, interceptor.proxy );
Assert.AreSame( mixin_instance, interceptor.mixin );
}
public RustTableGen(GeneratorContext generatorContext)
: base(generatorContext.Types)
{
this.generatorContext = generatorContext;
idConverter = RustIdentifierConverter.Create();
}
internal protected override CodeExpression GenerateObjectCreation (GeneratorContext ctx)
{
CodeObjectCreateExpression exp = new CodeObjectCreateExpression ();
PropertyDescriptor prop = (PropertyDescriptor) ClassDescriptor ["Name"];
exp.Parameters.Add (ctx.GenerateValue (prop.GetValue (Wrapped), prop.RuntimePropertyType));
prop = (PropertyDescriptor) ClassDescriptor ["Label"];
string lab = (string) prop.GetValue (Wrapped);
if (lab == "") lab = null;
exp.Parameters.Add (ctx.GenerateValue (lab, prop.RuntimePropertyType, prop.Translatable));
prop = (PropertyDescriptor) ClassDescriptor ["Tooltip"];
exp.Parameters.Add (ctx.GenerateValue (prop.GetValue (Wrapped), prop.RuntimePropertyType, prop.Translatable));
prop = (PropertyDescriptor) ClassDescriptor ["StockId"];
exp.Parameters.Add (ctx.GenerateValue (prop.GetValue (Wrapped), prop.RuntimePropertyType, prop.Translatable));
if (type == ActionType.Action)
exp.CreateType = new CodeTypeReference ("Gtk.Action", CodeTypeReferenceOptions.GlobalReference);
else if (type == ActionType.Toggle)
exp.CreateType = new CodeTypeReference ("Gtk.ToggleAction", CodeTypeReferenceOptions.GlobalReference);
else {
exp.CreateType = new CodeTypeReference ("Gtk.RadioAction", CodeTypeReferenceOptions.GlobalReference);
prop = (PropertyDescriptor) ClassDescriptor ["Value"];
exp.Parameters.Add (ctx.GenerateValue (prop.GetValue (Wrapped), typeof(int)));
}
return exp;
}
private void WriteMethod(GeneratorContext context, ApiGroup apiGroup, int indent)
{
foreach (var method in apiGroup.Methods)
{
var returnType = "void";
ReturnType returnTypeType = null;
if (method.ReturnType != null)
{
returnTypeType = context.Definition.FindReturnType(method.ReturnType, apiGroup.Name);
if (returnTypeType != null)
{
returnType = this.GetPropertyName(returnTypeType.ClassName, returnTypeType.Name);
if (method.IsValueType)
{
returnType = returnType.ToLower();
}
else
{
returnType = returnTypeType.ApiGroup + "." + returnType;
}
}
}
string postReturnType = null;
ReturnType postReturnTypeType = null;
if (method.PostReturnType != null)
{
postReturnTypeType = context.Definition.FindReturnType(method.PostReturnType, apiGroup.Name);
if (postReturnTypeType != null)
{
postReturnType = this.GetPropertyName(postReturnTypeType.ClassName, postReturnTypeType.Name);
postReturnType = postReturnTypeType.ApiGroup + "." + postReturnType;
}
}
var parameters = new List <Parameter>();
if (method.RequiresUserAuthentication)
{
parameters.Add(new Parameter("user", "UserAuthorization"));
}
var urlParams = this.GetUrlPathParameters(method.Path, NameTransformation.PascalCase);
foreach (var urlParam in urlParams)
{
parameters.Add(urlParam.Value);
}
if (method.UsesAcceptLanguage)
{
parameters.Add(new Parameter("acceptLanguages", "string[]", originalName: "acceptLanguages = null"));
}
// doc
this.text.WriteLine(indent, "/// <summary>");
this.text.WriteLine(indent, "/// " + method.Title);
this.text.WriteLine(indent, "/// </summary>");
if (method.Remark != null)
{
this.text.WriteLine(indent, "/// <remarks>");
this.text.WriteLine(indent, "/// " + method.Remark + "");
this.text.WriteLine(indent, "/// </remarks>");
}
// name and arguments
this.text.WriteLine(indent++, "public " + returnType + " " + this.GetPropertyName(method.MethodName, method.Path) + "(");
var sep = " ";
foreach (var parameter in parameters)
{
this.text.WriteLine(indent, sep + (parameter.Type ?? "string") + " "
+ parameter.Name + " "
+ (parameter.Value != null ? ("= " + parameter.Value) : string.Empty));
sep = ", ";
}
if (postReturnTypeType != null)
{
this.text.WriteLine(indent, ", " + postReturnType + " postData");
}
if (returnType != null && method.UseFieldSelectors)
{
this.text.WriteLine(indent, ", FieldSelector<" + returnType + "> fields = null");
}
this.text.WriteLine(--indent, ")");
this.text.WriteLine(indent++, "{");
// body / format url
if (urlParams.Count > 0)
{
this.text.WriteLine(indent, "string urlFormat = \"" + method.Path + "\";");
this.text.WriteLine(indent, "var url = FormatUrl(urlFormat, " + (method.UseFieldSelectors ? "fields" : "default(FieldSelector)") + ", " + string.Join(", ", urlParams.Values.Select(p => "\"" + p.OriginalName + "\", " + p.Name).ToArray()) + ");");
}
else if (method.Path.Contains("FieldSelector"))
{
this.text.WriteLine(indent, "string urlFormat = \"" + method.Path + "\";");
this.text.WriteLine(indent, "var url = FormatUrl(urlFormat, fields);");
}
else
{
this.text.WriteLine(indent, "var url = \"" + method.Path + "\";");
}
// body / create context
this.text.WriteLine();
text.WriteLine(indent, "var context = new RequestContext();");
if (method.RequiresUserAuthentication)
{
text.WriteLine(indent, "context.UserAuthorization = user;");
}
if (method.UsesAcceptLanguage)
{
text.WriteLine(indent, "context.AcceptLanguages = acceptLanguages;");
}
text.WriteLine(indent, "context.Method = \"" + method.HttpMethod + "\";");
text.WriteLine(indent, "context.UrlPath = this.LinkedInApi.Configuration.BaseApiUrl + url;");
if (postReturnTypeType != null)
{
if (postReturnTypeType.IsMultiPartStream)
{
this.text.WriteLine(indent, "this.CreateMultiPartStream(context, postData);");
}
else if (postReturnTypeType.IsOctetStream)
{
this.text.WriteLine(indent, "this.CreateOctetStream(context, postData);");
}
else
{
this.text.WriteLine(indent, "this.CreateJsonPostStream(context, postData);");
}
}
// body / execute
this.text.WriteLine();
text.WriteLine(indent++, "if (!this.ExecuteQuery(context))");
////text.WriteLine(indent--, "this.HandleXmlErrorResponse(context);");
////text.WriteLine(indent, "return this.HandleXmlResponse<" + returnType + ">(context);");
text.WriteLine(indent--, "this.HandleJsonErrorResponse(context);");
text.WriteLine(indent, "");
if (method.IsStreamOctetResultHandeling)
{
text.WriteLine(indent, @"
var result = string.Empty;
var headerETag = context.ResponseHeaders.GetValues(""eTag"");
if (headerETag.Length > 0)
{
result = headerETag.First();
result = result.TrimEnd('""').TrimStart('""');
}"
);
}
else if (method.IsUGCPostHandeling)
{
text.WriteLine(indent, @"
var result = string.Empty;
var headerETag = context.ResponseHeaders.GetValues(""X-RestLi-Id"");
if (headerETag.Length > 0)
{
result = headerETag.First();
result = result.TrimEnd('""').TrimStart('""');
}"
);
}
else if (method.IsIntResultHandeling)
{
text.WriteLine(indent, "var result = (int)context.HttpStatusCode;");
}
else if (method.IsStringResultHandeling)
{
text.WriteLine(indent, "var result = this.HandleRawResponse(context, System.Text.Encoding.UTF8);");
}
else
{
text.WriteLine(indent, "var result = this.HandleJsonResponse<" + returnType + ">(context);");
}
if (returnTypeType != null && returnTypeType.Headers != null)
{
foreach (var header in returnTypeType.Headers)
{
text.WriteLine(indent, "result." + header.PropertyName + " = this.ReadHeader<" + (header.Type ?? "string") + ">(context, \"" + header.Name + "\");");
}
}
text.WriteLine(indent, "return result;");
// body / handle
// body / return
////this.text.WriteLine(indent, "throw new NotImplementedException(url);");
this.text.WriteLine(--indent, "}");
this.text.WriteLine();
//this.text.WriteLine(--indent, "#if ASYNCTASKS");
indent++;
// doc
this.text.WriteLine(indent, "/// <summary>");
this.text.WriteLine(indent, "/// " + method.Title);
this.text.WriteLine(indent, "/// </summary>");
if (method.Remark != null)
{
this.text.WriteLine(indent, "/// <remarks>");
this.text.WriteLine(indent, "/// " + method.Remark + "");
this.text.WriteLine(indent, "/// </remarks>");
}
// name and arguments
this.text.WriteLine(indent++, "public async Task<" + returnType + "> " + this.GetPropertyName(method.MethodName, method.Path) + "Async(");
sep = " ";
foreach (var parameter in parameters)
{
this.text.WriteLine(indent, sep + (parameter.Type ?? "string") + " "
+ parameter.Name + " "
+ (parameter.Value != null ? ("= " + parameter.Value) : string.Empty));
sep = ", ";
}
if (postReturnTypeType != null)
{
this.text.WriteLine(indent, ", " + postReturnType + " postData");
}
if (returnType != null && method.UseFieldSelectors)
{
this.text.WriteLine(indent, ", FieldSelector<" + returnType + "> fields = null");
}
this.text.WriteLine(--indent, ")");
this.text.WriteLine(indent++, "{");
// body / format url
if (urlParams.Count > 0)
{
this.text.WriteLine(indent, "string urlFormat = \"" + method.Path + "\";");
this.text.WriteLine(indent, "var url = FormatUrl(urlFormat, " + (method.UseFieldSelectors ? "fields" : "default(FieldSelector)") + ", " + string.Join(", ", urlParams.Values.Select(p => "\"" + p.OriginalName + "\", " + p.Name).ToArray()) + ");");
}
else if (method.Path.Contains("FieldSelector"))
{
this.text.WriteLine(indent, "string urlFormat = \"" + method.Path + "\";");
this.text.WriteLine(indent, "var url = FormatUrl(urlFormat, fields);");
}
else
{
this.text.WriteLine(indent, "var url = \"" + method.Path + "\";");
}
// body / create context
this.text.WriteLine();
text.WriteLine(indent, "var context = new RequestContext();");
if (method.RequiresUserAuthentication)
{
text.WriteLine(indent, "context.UserAuthorization = user;");
}
if (method.UsesAcceptLanguage)
{
text.WriteLine(indent, "context.AcceptLanguages = acceptLanguages;");
}
text.WriteLine(indent, "context.Method = \"" + method.HttpMethod + "\";");
text.WriteLine(indent, "context.UrlPath = this.LinkedInApi.Configuration.BaseApiUrl + url;");
if (postReturnTypeType != null)
{
if (postReturnTypeType.IsMultiPartStream)
{
this.text.WriteLine(indent, "this.CreateMultiPartStream(context, postData);");
}
else if (postReturnTypeType.IsOctetStream)
{
this.text.WriteLine(indent, "this.CreateOctetStream(context, postData);");
}
else
{
this.text.WriteLine(indent, "this.CreateJsonPostStream(context, postData);");
}
}
// body / execute
this.text.WriteLine();
text.WriteLine(indent, "var exec = await this.ExecuteQueryAsync(context);");
text.WriteLine(indent++, "if (!exec)");
////text.WriteLine(indent--, "this.HandleXmlErrorResponse(context);");
////text.WriteLine(indent, "return this.HandleXmlResponse<" + returnType + ">(context);");
text.WriteLine(indent--, "this.HandleJsonErrorResponse(context);");
text.WriteLine(indent, "");
if (method.IsStreamOctetResultHandeling)
{
text.WriteLine(indent, @"
var result = string.Empty;
var headerETag = context.ResponseHeaders.GetValues(""eTag"");
if (headerETag.Length > 0)
{
result = headerETag.First();
result = result.TrimEnd('""').TrimStart('""');
}"
);
}
else if (method.IsUGCPostHandeling)
{
text.WriteLine(indent, @"
var result = string.Empty;
var headerETag = context.ResponseHeaders.GetValues(""X-RestLi-Id"");
if (headerETag.Length > 0)
{
result = headerETag.First();
result = result.TrimEnd('""').TrimStart('""');
}"
);
}
else if (method.IsIntResultHandeling)
{
text.WriteLine(indent, "var result = (int)context.HttpStatusCode;");
}
else if (method.IsStringResultHandeling)
{
text.WriteLine(indent, "var result = this.HandleRawResponse(context, System.Text.Encoding.UTF8);");
}
else
{
text.WriteLine(indent, "var result = this.HandleJsonResponse<" + returnType + ">(context);");
}
if (returnTypeType != null && returnTypeType.Headers != null)
{
foreach (var header in returnTypeType.Headers)
{
text.WriteLine(indent, "result." + header.PropertyName + " = this.ReadHeader<" + (header.Type ?? "string") + ">(context, \"" + header.Name + "\");");
}
}
text.WriteLine(indent, "return result;");
// body / handle
// body / return
////this.text.WriteLine(indent, "throw new NotImplementedException(url);");
this.text.WriteLine(--indent, "}");
//this.text.WriteLine(--indent, "#endif");
indent++;
this.text.WriteLine(indent, "");
}
}
private string GetDefaultValue(GeneratorContext ctx, FieldDescriptorProto obj, string typeName)
{
string defaultValue = null;
bool isOptional = obj.label == FieldDescriptorProto.Label.LabelOptional;
if (isOptional || ctx.EmitRequiredDefaults || obj.type == FieldDescriptorProto.Type.TypeEnum)
{
defaultValue = obj.DefaultValue;
if (obj.type == FieldDescriptorProto.Type.TypeString)
{
defaultValue = string.IsNullOrEmpty(defaultValue) ? "\"\""
: ("@\"" + (defaultValue ?? "").Replace("\"", "\"\"") + "\"");
}
else if (obj.type == FieldDescriptorProto.Type.TypeDouble)
{
switch (defaultValue)
{
case "inf": defaultValue = "double.PositiveInfinity"; break;
case "-inf": defaultValue = "double.NegativeInfinity"; break;
case "nan": defaultValue = "double.NaN"; break;
}
}
else if (obj.type == FieldDescriptorProto.Type.TypeFloat)
{
switch (defaultValue)
{
case "inf": defaultValue = "float.PositiveInfinity"; break;
case "-inf": defaultValue = "float.NegativeInfinity"; break;
case "nan": defaultValue = "float.NaN"; break;
}
}
else if (obj.type == FieldDescriptorProto.Type.TypeEnum)
{
var enumType = ctx.TryFind <EnumDescriptorProto>(obj.TypeName);
if (enumType != null)
{
EnumValueDescriptorProto found = null;
if (!string.IsNullOrEmpty(defaultValue))
{
found = enumType.Values.FirstOrDefault(x => x.Name == defaultValue);
}
else if (ctx.Syntax == FileDescriptorProto.SyntaxProto2)
{
// find the first one; if that is a zero, we don't need it after all
found = enumType.Values.FirstOrDefault();
if (found != null && found.Number == 0)
{
if (!isOptional)
{
found = null; // we don't need it after all
}
}
}
// for proto3 the default is 0, so no need to do anything - GetValueOrDefault() will do it all
if (found != null)
{
defaultValue = ctx.NameNormalizer.GetName(found);
}
if (!string.IsNullOrWhiteSpace(defaultValue))
{
defaultValue = typeName + "." + defaultValue;
}
}
}
}
return(defaultValue);
}
internal protected override void GenerateBuildCode (GeneratorContext ctx, CodeExpression var)
{
if (!String.IsNullOrEmpty (UIManagerName)) {
// Create an UI manager
CodeFieldReferenceExpression uixp = new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), UIManagerName);
CodeAssignStatement uim_init = new CodeAssignStatement (uixp, new CodeObjectCreateExpression (typeof (Gtk.UIManager).ToGlobalTypeRef ()));
ctx.Statements.Add (uim_init);
includedActionGroups = new ArrayList ();
// Generate action group creation
foreach (ActionGroup actionGroup in actionGroups) {
// Create the action group
string grpVar = ctx.NewId ();
CodeVariableDeclarationStatement uidec = new CodeVariableDeclarationStatement (
typeof (Gtk.ActionGroup).ToGlobalTypeRef (),
grpVar,
actionGroup.GenerateObjectCreation (ctx)
);
ctx.Statements.Add (uidec);
actionGroup.GenerateBuildCode (ctx, new CodeVariableReferenceExpression (grpVar));
// Insert the action group in the UIManager
CodeMethodInvokeExpression mi = new CodeMethodInvokeExpression (
uixp,
"InsertActionGroup",
new CodeVariableReferenceExpression (grpVar),
new CodePrimitiveExpression (includedActionGroups.Count)
);
ctx.Statements.Add (mi);
includedActionGroups.Add (actionGroup);
}
// Adds the accel group to the window
Window w = GetTopLevel () as Window;
if (w != null) {
CodeMethodInvokeExpression ami = new CodeMethodInvokeExpression (
ctx.WidgetMap.GetWidgetExp (w),
"AddAccelGroup",
new CodePropertyReferenceExpression (
uixp,
"AccelGroup"
)
);
ctx.Statements.Add (ami);
} else {
// There is no top level window, this must be a custom widget.
// The only option is to register the accel group when
// the widget is realized. This is done by the Bin wrapper.
}
}
if (tooltip != null && tooltip.Length > 0)
GetTopLevel().GenerateTooltip (ctx, this);
base.GenerateBuildCode (ctx, var);
}
internal protected override CodeExpression GenerateObjectCreation(GeneratorContext ctx)
{
return(new CodeObjectCreateExpression(ClassDescriptor.WrappedTypeName.ToGlobalTypeRef(), new CodePrimitiveExpression(null)));
}
protected override void GeneratePropertySet (GeneratorContext ctx, CodeExpression var, PropertyDescriptor prop)
{
// Those properties are handled in GeneratePostBuildCode
if (prop.Name == "Visible" || prop.Name == "HasDefault")
return;
// Don't generate a name for unselectable widgets
if (prop.Name == "Name" && Unselectable)
return;
base.GeneratePropertySet (ctx, var, prop);
}
public virtual Type CreateCustomInterfaceProxy(Type[] interfaces, Type type, GeneratorContext context)
{
InterfaceProxyGenerator generator = new InterfaceProxyGenerator(_scope, context);
return(generator.GenerateCode(interfaces, type));
}
public ClassProxyGenerator(ModuleScope scope, GeneratorContext context) : base(scope, context)
{
}
private void WriteReturnTypes(GeneratorContext context, ReturnType returnType, ApiGroup apiGroup)
{
int indent = 0;
this.text.WriteLine(indent, "// WriteReturnTypes(" + apiGroup.Name + ", " + returnType.Name + ")");
this.text.WriteLine(indent, "namespace " + this.RootNamespace + "." + apiGroup.Name);
this.text.WriteLine(indent++, "{");
this.WriteNamespace(indent, "System");
this.WriteNamespace(indent, "System.Collections.Generic");
this.WriteNamespace(indent, "System.Xml.Serialization");
this.WriteNamespace(indent, "Newtonsoft.Json");
this.WriteNamespace(indent, "Newtonsoft.Json.Linq");
this.text.WriteLine();
this.text.WriteLine(indent, "/// <summary>");
this.text.WriteLine(indent, "/// Name: '" + returnType.Name + "'");
this.text.WriteLine(indent, "/// </summary>");
if (returnType.Remark != null)
{
this.text.WriteLine(indent, "/// <remarks>");
this.text.WriteLine(indent, "/// " + returnType.Remark + "");
this.text.WriteLine(indent, "/// </remarks>");
}
var className = this.GetPropertyName(returnType.ClassName, returnType.Name);
this.text.WriteLine(indent, "[Serializable, XmlRoot(\"" + returnType.Name + "\")]");
this.text.WriteLine(indent, "public class " + className);
this.text.WriteLine(indent++, "{");
foreach (var itemGroup in returnType.Fields.GroupBy(f => f.FieldName.PropertyName).ToArray())
{
var item = itemGroup.First();
var isCollection = item.IsCollection;
var type = item.Type ?? item.FieldName.ClassName ?? "string";
ReturnType fieldReturnType = null;
if (!csharpTypes.Contains(type))
{
fieldReturnType = context.Definition.FindReturnType(type);
if (fieldReturnType != null && !type.Contains('.'))
{
type = fieldReturnType.ClassName ?? Namify(fieldReturnType.Name);
}
}
if (isCollection)
{
type = "List<" + type + ">";
}
this.text.WriteLine(indent, "/// <summary>");
foreach (var subItem in itemGroup)
{
this.text.WriteLine(indent, "/// Field: '" + subItem.Name + "' (" + (subItem.IsDefault ? "default" : "on-demand") + ")");
}
foreach (var subItem in itemGroup.Where(f => f.Selectors != null).SelectMany(f => f.Selectors))
{
this.text.WriteLine(indent, "/// Field: '" + subItem.Name + "'");
}
var xmlAttribute = item.IsAttribute ? "XmlAttribute" : "XmlElement";
var xmlAttributeNameProp = item.IsAttribute ? "AttributeName" : "ElementName";
var jsonName = (item.IsAttribute ? "_" : "") + item.FieldName.ApiName; // Namify(item.FieldName.ApiName, NameTransformation.PascalCase);
//if (item.IsCollection)
// jsonName = "values";
this.text.WriteLine(indent, "/// </summary>");
this.text.WriteLine(indent, (item.Ignore ? "////" : "") + "[" + xmlAttribute + "(" + xmlAttributeNameProp + " = \"" + item.FieldName.ApiName + "\")]");
this.text.WriteLine(indent, (item.Ignore ? "////" : "") + "[JsonProperty(PropertyName = \"" + jsonName + "\")]");
this.text.WriteLine(indent, "public " + type + " " + item.FieldName.PropertyName + " { get; set; }");
this.text.WriteLine();
}
if (returnType.Headers != null)
{
foreach (var item in returnType.Headers)
{
var isCollection = item.IsCollection;
var type = item.Type ?? item.FieldName.ClassName ?? "string";
ReturnType fieldReturnType = null;
if (!csharpTypes.Contains(type))
{
fieldReturnType = context.Definition.FindReturnType(type);
if (fieldReturnType != null)
{
type = fieldReturnType.ClassName ?? Namify(fieldReturnType.Name);
}
}
if (isCollection)
{
type = "List<" + type + ">";
}
this.text.WriteLine(indent, "/// <summary>");
this.text.WriteLine(indent, "/// HTTP header '" + item.Name + "'");
this.text.WriteLine(indent, "/// </summary>");
this.text.WriteLine(indent, "public " + type + " " + item.FieldName.PropertyName + " { get; set; }");
this.text.WriteLine();
}
}
this.text.WriteLine(--indent, "}");
this.text.WriteLine(--indent, "}");
this.text.WriteLine();
}
/// <summary>
/// Ends an extensions block
/// </summary>
protected override void WriteExtensionsFooter(GeneratorContext ctx, DescriptorProto obj, ref object state)
{
ctx.Outdent().WriteLine("}");
}
internal protected override void GeneratePostBuildCode (GeneratorContext ctx, CodeExpression var)
{
base.GeneratePostBuildCode (ctx, var);
// The visible property is generated here to ensure that widgets are made visible
// after they have been fully built
PropertyDescriptor prop = ClassDescriptor ["Visible"] as PropertyDescriptor;
if (prop != null && prop.PropertyType == typeof(bool) && !(bool) prop.GetValue (Wrapped)) {
ctx.Statements.Add (
new CodeMethodInvokeExpression (
var,
"Hide"
)
);
}
// The HasDefault property can only be assigned when the widget is added to the window
prop = ClassDescriptor ["HasDefault"] as PropertyDescriptor;
if (prop != null && (bool) prop.GetValue (Wrapped)) {
ctx.Statements.Add (
new CodeAssignStatement (
new CodePropertyReferenceExpression (
var,
"HasDefault"
),
new CodePrimitiveExpression (true)
)
);
}
}
protected override void WriteMessageHeader(GeneratorContext ctx, DescriptorProto obj, ref object state)
{
throw new NotImplementedException();
}
protected CodeExpression GenerateUiManagerElement (GeneratorContext ctx, ActionTree tree)
{
Widget topLevel = GetTopLevel ();
string uiName = topLevel.UIManagerName;
if (uiName != null) {
CodeFieldReferenceExpression uiManager = new CodeFieldReferenceExpression (new CodeThisReferenceExpression (), uiName);
if (topLevel.includedActionGroups == null)
topLevel.includedActionGroups = new ArrayList ();
// Add to the uimanager all action groups required by the
// actions of the tree
foreach (ActionGroup grp in tree.GetRequiredGroups ()) {
if (!topLevel.includedActionGroups.Contains (grp)) {
// Insert the action group in the UIManager
CodeMethodInvokeExpression mi = new CodeMethodInvokeExpression (
uiManager,
"InsertActionGroup",
ctx.GenerateValue (grp, typeof(ActionGroup)),
new CodePrimitiveExpression (topLevel.includedActionGroups.Count)
);
ctx.Statements.Add (mi);
topLevel.includedActionGroups.Add (grp);
}
}
tree.GenerateBuildCode (ctx, uiManager);
return new CodeMethodInvokeExpression (
uiManager,
"GetWidget",
new CodePrimitiveExpression ("/" + Wrapped.Name)
);
}
return null;
}
public virtual Expression OnCreateGetBytes(ParameterExpression obj, GeneratorContext context, Expression lastResult)
{
return(lastResult);
}
public object RecreateClassProxy(SerializationInfo info, StreamingContext context)
{
bool delegateBaseSer = info.GetBoolean("__delegateToBase");
if (!delegateBaseSer)
{
_data = (object[]) info.GetValue("__data", typeof(object[]) );
}
object proxy = null;
GeneratorContext genContext = new GeneratorContext();
if (_mixins.Length != 0)
{
foreach(object mixin in _mixins)
{
genContext.AddMixinInstance(mixin);
}
}
ClassProxyGenerator cpGen = new ClassProxyGenerator( _scope, genContext );
Type proxy_type;
if (_mixins.Length == 0)
{
proxy_type = cpGen.GenerateCode( _baseType, _interfaces );
}
else
{
proxy_type = cpGen.GenerateCustomCode( _baseType, _interfaces );
}
if (delegateBaseSer)
{
proxy = Activator.CreateInstance( proxy_type, new object[] { info, context } );
}
else
{
if (_mixins.Length == 0)
{
proxy = Activator.CreateInstance( proxy_type, new object[] { _interceptor } );
}
else
{
ArrayList args = new ArrayList();
args.Add(_interceptor);
args.Add(genContext.MixinsAsArray());
proxy = Activator.CreateInstance( proxy_type, args.ToArray() );
}
MemberInfo[] members = FormatterServices.GetSerializableMembers( _baseType );
FormatterServices.PopulateObjectMembers(proxy, members, _data);
}
return proxy;
}
public virtual void AfterAllCreateGetBytes(GeneratorContext context)
{
}
public MarkdownProcessor(IFileSystem fileSystem, ILogger logger, IUrlProvider urlProvider, GeneratorContext context)
{
this._log = logger;
this._fileSystem = fileSystem;
this._urlProvider = urlProvider;
this._context = context;
}
public virtual Func <Expression, Expression> OnGetLoopController(ParameterExpression bytes, ParameterExpression startIndex, GeneratorContext context, Func <Expression, Expression> lastResult)
{
return(lastResult);
}
public void MixinImplementingMoreThanOneInterface()
{
GeneratorContext context = new GeneratorContext();
ComplexMixin mixin_instance = new ComplexMixin();
context.AddMixinInstance( mixin_instance );
AssertInvocationInterceptor interceptor = new AssertInvocationInterceptor();
object proxy = _generator.CreateCustomClassProxy(
typeof(SimpleClass), interceptor, context );
Assert.IsNotNull(proxy);
Assert.IsTrue( typeof(SimpleClass).IsAssignableFrom( proxy.GetType() ) );
Assert.IsFalse( interceptor.Invoked );
IThird inter3 = proxy as IThird;
Assert.IsNotNull(inter3);
inter3.DoThird();
Assert.IsTrue( interceptor.Invoked );
Assert.AreSame( proxy, interceptor.proxy );
Assert.AreSame( mixin_instance, interceptor.mixin );
ISecond inter2 = proxy as ISecond;
Assert.IsNotNull(inter2);
inter2.DoSecond();
Assert.IsTrue( interceptor.Invoked );
Assert.AreSame( proxy, interceptor.proxy );
Assert.AreSame( mixin_instance, interceptor.mixin );
IFirst inter1 = proxy as IFirst;
Assert.IsNotNull(inter1);
inter1.DoFirst();
Assert.IsTrue( interceptor.Invoked );
Assert.AreSame( proxy, interceptor.proxy );
Assert.AreSame( mixin_instance, interceptor.mixin );
}
public virtual Expression OnCreateToObject(ParameterExpression bytes, ParameterExpression startIndex, GeneratorContext context, Expression lastResult)
{
return(lastResult);
}
public InterfaceProxyGenerator(ModuleScope scope, GeneratorContext context) : base(scope, context)
{
}
protected override void WriteField(GeneratorContext ctx, FieldDescriptorProto obj, ref object state, OneOfStub[] oneOfs)
{
throw new NotImplementedException();
}
internal protected override void GenerateBuildCode (GeneratorContext ctx, CodeExpression var)
{
if (Type == ActionType.Radio) {
CodeExpression groupExp = GroupManager.GenerateGroupExpression (ctx, this);
ctx.Statements.Add (
new CodeAssignStatement (
new CodePropertyReferenceExpression (var, "Group"),
groupExp)
);
}
else if (type == ActionType.Toggle) {
if (Active) {
ctx.Statements.Add (
new CodeAssignStatement (
new CodePropertyReferenceExpression (var, "Active"),
new CodePrimitiveExpression (true))
);
}
if (DrawAsRadio) {
ctx.Statements.Add (
new CodeAssignStatement (
new CodePropertyReferenceExpression (var, "DrawAsRadio"),
new CodePrimitiveExpression (true))
);
}
}
base.GenerateBuildCode (ctx, var);
}
public override object Generate(GeneratorContext context)
{
return(Random.Next(int.MinValue, int.MaxValue));
}
private void WriteReturnTypeFields(GeneratorContext context, ApiGroup apiGroup, ReturnType[] returnTypes)
{
int indent = 0;
this.text.WriteLine(indent, "// WriteReturnTypeFields(" + apiGroup.Name + ")");
this.text.WriteLine(indent, "namespace " + this.RootNamespace + "." + apiGroup.Name);
this.text.WriteLine(indent++, "{");
this.WriteNamespace(indent, "System");
this.WriteNamespace(indent, "System.Collections.Generic");
this.WriteNamespace(indent, "System.Xml.Serialization");
this.text.WriteLine();
this.text.WriteLine(indent, "/// <summary>");
this.text.WriteLine(indent, "/// Field selectors for the '" + string.Join("', '", returnTypes.Select(r => r.Name).ToArray()) + "' return types.");
this.text.WriteLine(indent, "/// </summary>");
this.text.WriteLine(indent++, "public static class " + apiGroup.Name + "Fields {");
foreach (var returnType in returnTypes)
{
////var returnTypeName = this.GetPropertyName(returnType.ClassName, returnType.Name);
////this.text.WriteLine(indent++, "public static FieldSelector<" + returnTypeName + "> Fields(this FieldSelector<" + returnTypeName + "> me) {");
////this.text.WriteLine(indent, "return me.Add(\"" + field.Name + "\");");
////this.text.WriteLine(--indent, "}");
////this.text.WriteLine(indent, "");
var returnTypeName = this.GetPropertyName(returnType.ClassName, returnType.Name);
////this.text.WriteLine(indent, "// return type: " + (returnType.ClassName ?? returnType.Name));
var allFields = new List <string>();
foreach (var fieldGroup in returnType.Fields.GroupBy(f => f.Name).ToArray())
{
var field = fieldGroup.First();
var selectors = fieldGroup.Where(f => f.Selectors != null).SelectMany(f => f.Selectors).ToArray();
if (selectors.Length == 0 && returnType.AutoGenerateFieldSelectors && !field.IsAttribute)
{
var name = field.Name;
var fieldName = this.GetPropertyName(null, field.Name);
allFields.Add(name);
WriteReturnTypeField(indent, returnTypeName, fieldName, name);
}
else
{
foreach (var selector in selectors)
{
var name = selector.Name;
var fieldName = this.GetPropertyName(selector.PropertyName, name);
allFields.Add(name);
WriteReturnTypeField(indent, returnTypeName, fieldName, name);
}
}
}
if (returnType.Selectors != null)
{
foreach (var customSelector in returnType.Selectors)
{
if (!allFields.Contains(customSelector.Name))
{
var fieldName = this.GetPropertyName(customSelector.PropertyName, customSelector.Name);
WriteReturnTypeField(indent, returnTypeName, fieldName, customSelector.Name);
allFields.Add(customSelector.Name);
}
}
}
if (returnType.ImportFieldSelectors != null)
{
foreach (var import in returnType.ImportFieldSelectors)
{
if (import.ReturnType != null)
{
var type = context.Definition.FindReturnType(import.ReturnType);
if (type != null)
{
foreach (var field in type.Fields)
{
var fullName = import.Name + ":(" + field.Name + ")";
var fullPropertyName = this.GetPropertyName(null, import.Name) + this.GetPropertyName(field.PropertyName, field.Name);
WriteReturnTypeField(indent, returnTypeName, fullPropertyName, fullName);
allFields.Add(fullName);
}
}
}
}
}
if (allFields.Count > 0)
{
this.text.WriteLine(indent, "/// <summary>");
this.text.WriteLine(indent, "/// Includes all the fields.");
this.text.WriteLine(indent, "/// </summary>");
this.text.WriteLine(indent, "/// <param name=\"me\">The field selector.</param>");
this.text.WriteLine(indent, "/// <returns>The field selector.</returns>");
this.text.Write(indent++, "public static FieldSelector<" + returnTypeName + "> WithAllFields(this FieldSelector<" + returnTypeName + "> me) { ");
this.text.Write(@"return me.AddRange(""");
var sep = "";
for (int i = 0; i < allFields.Count; i++)
{
var name = allFields[i];
var slash = name.IndexOf('/');
if (slash > 0)
{
name = name.Substring(0, slash);
}
this.text.Write(sep);
this.text.Write(name);
sep = "\", \"";
}
this.text.Write("\"); ");
this.text.WriteLine("}");
indent--;
this.text.WriteLine(indent, "");
}
else
{
////this.text.WriteLine(indent, "// allFields.Count == 0");
}
////this.text.WriteLine(indent, "");
}
this.text.WriteLine(--indent, "}");
this.text.WriteLine(--indent, "}");
this.text.WriteLine();
}
protected override void WriteEnumFooter(GeneratorContext ctx, EnumDescriptorProto obj, ref object state)
{
throw new NotImplementedException();
}
