private static void WriteEndClass( IndentingTextWriter writer, bool hasNamespace )
{
Contract.Requires( writer != null );
if ( hasNamespace )
{
writer.Unindent();
writer.WriteLine( "}" );
}
writer.Unindent();
writer.Write( "}" );
}
private void ShowComponents(IndentingTextWriter writer)
{
Type typeSig;
Type typeRes;
string kind;
if (_kind == null)
{
// Show commands.
typeSig = typeof(SignatureCommand);
typeRes = typeof(ICommand);
kind = "Command";
writer.WriteLine("Available commands:");
}
else
{
kind = _kind.ToLowerInvariant();
var sigs = _env.ComponentCatalog.GetAllSignatureTypes();
typeSig = sigs.FirstOrDefault(t => ComponentCatalog.SignatureToString(t).ToLowerInvariant() == kind);
if (typeSig == null)
{
typeSig = sigs.FirstOrDefault(t => ComponentCatalog.SignatureToString(t).StartsWithInvariantCultureIgnoreCase(kind));
if (typeSig == null)
{
writer.WriteLine("Couldn't find kind '{0}'", kind);
ListKinds(writer);
return;
}
}
typeRes = typeof(object);
writer.WriteLine("Available components for kind '{0}':", ComponentCatalog.SignatureToString(typeSig));
}
var infos = _env.ComponentCatalog.GetAllDerivedClasses(typeRes, typeSig)
.Where(x => !x.IsHidden)
.OrderBy(x => x.LoadNames[0].ToLowerInvariant());
using (writer.Nest())
{
var components = new List <Component>();
foreach (var info in infos)
{
_env.Assert(info.LoadNames.Count > 0);
writer.Write("{0}", info.LoadNames[0]);
if (!string.IsNullOrWhiteSpace(info.UserName))
{
writer.Write(": {0}", info.UserName);
}
writer.WriteLine();
using (writer.Nest())
ShowAliases(writer, info.LoadNames);
components.Add(new Component(kind, info, info.CreateArguments()));
}
if (components.Count > 0)
{
Serialize(components);
}
}
}
/// <summary>
/// Generate enums for subcomponents. Uses ReflectionUtils to filter only the subcomponents that match the base type and the signature.
/// </summary>
/// <param name="w"></param>
/// <param name="arg"></param>
/// <param name="seen"></param>
protected void GenerateEnums(IndentingTextWriter w, CmdParser.ArgInfo.Arg arg, HashSet <Tuple <Type, Type> > seen)
{
if (Exclude.Contains(arg.LongName))
{
return;
}
var moreEnums = new List <CmdParser.ArgInfo.Arg>();
if (arg.IsHidden || !arg.IsSubComponentItemType)
{
return;
}
Contracts.Assert(arg.ItemType.GetGenericTypeDefinition() == typeof(SubComponent <,>));
var types = arg.ItemType.GetGenericArguments();
var baseType = types[0];
var sigType = types[1];
var key = new Tuple <Type, Type>(baseType, sigType);
if (seen.Contains(key) || IsTrainer(sigType) || sigType == typeof(SignatureDataLoader))
{
return;
}
seen.Add(key);
var typeName = EnumName(arg, sigType);
w.WriteLine("/// <summary> Available choices for {0} </summary>", sigType);
w.WriteLine("public enum {0}", typeName);
w.Write("{");
using (w.Nest())
{
var pre = "";
if (arg.NullName != null)
{
w.WriteLine();
GenerateEnumValue(w, null);
pre = ",";
}
var infos = ComponentCatalog.GetAllDerivedClasses(baseType, sigType);
foreach (var info in infos)
{
w.WriteLine(pre);
if (pre != "")
{
w.WriteLine();
}
pre = ",";
GenerateEnumValue(w, info);
var args = info.CreateArguments();
if (args == null)
{
continue;
}
var argInfo = CmdParser.GetArgInfo(args.GetType(), args);
moreEnums.AddRange(argInfo.Args);
}
w.WriteLine();
}
w.WriteLine("}");
w.WriteLine();
foreach (var argument in moreEnums)
{
GenerateEnums(w, argument, seen);
}
}
protected virtual void GenerateParameter(IndentingTextWriter w, string type, string name)
{
w.Write("{0} {1}", type, name);
}
private void GenerateInputFields(IndentingTextWriter writer, Type inputType, ModuleCatalog catalog, string rootNameSpace)
{
var defaults = Activator.CreateInstance(inputType);
foreach (var fieldInfo in inputType.GetFields())
{
var inputAttr =
fieldInfo.GetCustomAttributes(typeof(ArgumentAttribute), false).FirstOrDefault() as ArgumentAttribute;
if (inputAttr == null || inputAttr.Visibility == ArgumentAttribute.VisibilityType.CmdLineOnly)
{
continue;
}
if (fieldInfo.FieldType == typeof(JObject))
{
continue;
}
CSharpGeneratorUtils.GenerateSummary(writer, inputAttr.HelpText);
if (fieldInfo.FieldType == typeof(JArray))
{
writer.WriteLine($"public Experiment {CSharpGeneratorUtils.Capitalize(inputAttr.Name ?? fieldInfo.Name)} {{ get; set; }}");
writer.WriteLine();
continue;
}
var inputTypeString = CSharpGeneratorUtils.GetInputType(catalog, fieldInfo.FieldType, _generatedClasses, rootNameSpace);
if (CSharpGeneratorUtils.IsComponent(fieldInfo.FieldType))
{
writer.WriteLine("[JsonConverter(typeof(ComponentSerializer))]");
}
if (CSharpGeneratorUtils.Capitalize(inputAttr.Name ?? fieldInfo.Name) != (inputAttr.Name ?? fieldInfo.Name))
{
writer.WriteLine($"[JsonProperty(\"{inputAttr.Name ?? fieldInfo.Name}\")]");
}
// For range attributes on properties
if (fieldInfo.GetCustomAttributes(typeof(TlcModule.RangeAttribute), false).FirstOrDefault()
is TlcModule.RangeAttribute ranAttr)
{
writer.WriteLine(ranAttr.ToString());
}
// For obsolete/deprecated attributes
if (fieldInfo.GetCustomAttributes(typeof(ObsoleteAttribute), false).FirstOrDefault()
is ObsoleteAttribute obsAttr)
{
writer.WriteLine($"[System.Obsolete(\"{obsAttr.Message}\")]");
}
// For sweepable ranges on properties
if (fieldInfo.GetCustomAttributes(typeof(TlcModule.SweepableParamAttribute), false).FirstOrDefault()
is TlcModule.SweepableParamAttribute sweepableParamAttr)
{
if (string.IsNullOrEmpty(sweepableParamAttr.Name))
{
sweepableParamAttr.Name = fieldInfo.Name;
}
writer.WriteLine(sweepableParamAttr.ToString());
}
writer.Write($"public {inputTypeString} {CSharpGeneratorUtils.Capitalize(inputAttr.Name ?? fieldInfo.Name)} {{ get; set; }}");
var defaultValue = CSharpGeneratorUtils.GetValue(catalog, fieldInfo.FieldType, fieldInfo.GetValue(defaults), _generatedClasses, rootNameSpace);
if (defaultValue != null)
{
writer.Write($" = {defaultValue};");
}
writer.WriteLine();
writer.WriteLine();
}
}
private void GenerateEnums(IndentingTextWriter writer, Type inputType, string currentNamespace)
{
foreach (var fieldInfo in inputType.GetFields())
{
var inputAttr = fieldInfo.GetCustomAttributes(typeof(ArgumentAttribute), false).FirstOrDefault() as ArgumentAttribute;
if (inputAttr == null || inputAttr.Visibility == ArgumentAttribute.VisibilityType.CmdLineOnly)
{
continue;
}
var type = CSharpGeneratorUtils.ExtractOptionalOrNullableType(fieldInfo.FieldType);
if (_generatedClasses.IsGenerated(type.FullName))
{
continue;
}
if (!type.IsEnum)
{
var typeEnum = TlcModule.GetDataType(type);
if (typeEnum == TlcModule.DataKind.Unknown)
{
GenerateEnums(writer, type, currentNamespace);
}
continue;
}
var enumType = Enum.GetUnderlyingType(type);
var apiName = _generatedClasses.GetApiName(type, currentNamespace);
if (enumType == typeof(int))
{
writer.WriteLine($"public enum {apiName}");
}
else
{
Contracts.Assert(enumType == typeof(byte));
writer.WriteLine($"public enum {apiName} : byte");
}
_generatedClasses.MarkAsGenerated(type.FullName);
writer.Write("{");
writer.Indent();
var names = Enum.GetNames(type);
var values = Enum.GetValues(type);
string prefix = "";
for (int i = 0; i < names.Length; i++)
{
var name = names[i];
var value = values.GetValue(i);
writer.WriteLine(prefix);
if (enumType == typeof(int))
{
writer.Write($"{name} = {(int)value}");
}
else
{
Contracts.Assert(enumType == typeof(byte));
writer.Write($"{name} = {(byte)value}");
}
prefix = ",";
}
writer.WriteLine();
writer.Outdent();
writer.WriteLine("}");
writer.WriteLine();
}
}
