private string AppendType(ref StringBuilderWrapper sb, MetadataType type, string lastNS,
CreateTypeOptions options)
{
sb = sb.Indent();
sb.AppendLine();
AppendComments(sb, type.Description);
if (type.Routes != null)
{
AppendAttributes(sb, type.Routes.ConvertAll(x => x.ToMetadataAttribute()));
}
AppendAttributes(sb, type.Attributes);
AppendDataContract(sb, type.DataContract);
var typeName = Type(type.Name, type.GenericArgs);
if (type.IsEnum.GetValueOrDefault())
{
sb.AppendLine("public static enum {0}".Fmt(typeName));
sb.AppendLine("{");
sb = sb.Indent();
if (type.EnumNames != null)
{
var hasIntValue = false;
for (var i = 0; i < type.EnumNames.Count; i++)
{
var name = type.EnumNames[i];
var value = type.EnumValues != null ? type.EnumValues[i] : null;
var delim = i == type.EnumNames.Count - 1 ? ";" : ",";
var serializeAs = JsConfig.TreatEnumAsInteger || (type.Attributes.Safe().Any(x => x.Name == "Flags"))
? "@SerializedName(\"{0}\") ".Fmt(value)
: "";
sb.AppendLine(value == null
? "{0}{1}".Fmt(name.ToPascalCase(), delim)
: serializeAs + "{0}({1}){2}".Fmt(name.ToPascalCase(), value, delim));
hasIntValue = hasIntValue || value != null;
}
if (hasIntValue)
{
sb.AppendLine();
sb.AppendLine("private final int value;");
sb.AppendLine("{0}(final int intValue) {{ value = intValue; }}".Fmt(typeName));
sb.AppendLine("public int getValue() { return value; }");
}
}
sb = sb.UnIndent();
sb.AppendLine("}");
}
else
{
var defType = type.IsInterface()
? "interface"
: "class";
var extends = new List<string>();
//: BaseClass, Interfaces
if (type.Inherits != null)
extends.Add(Type(type.Inherits).InheritedType());
string responseTypeExpression = null;
var interfaces = new List<string>();
if (options.ImplementsFn != null)
{
var implStr = options.ImplementsFn();
if (!string.IsNullOrEmpty(implStr))
{
interfaces.Add(implStr);
if (implStr.StartsWith("IReturn<"))
{
var types = implStr.RightPart('<');
var returnType = types.Substring(0, types.Length - 1);
//Can't get .class from Generic Type definition
responseTypeExpression = returnType.Contains("<")
? "new TypeToken<{0}>(){{}}.getType()".Fmt(returnType)
: "{0}.class".Fmt(returnType);
}
}
if (!type.Implements.IsEmpty())
{
foreach (var interfaceRef in type.Implements)
{
interfaces.Add(Type(interfaceRef));
}
}
}
var extend = extends.Count > 0
? " extends " + extends[0]
: "";
if (interfaces.Count > 0)
extend += " implements " + string.Join(", ", interfaces.ToArray());
var addPropertyAccessors = Config.AddPropertyAccessors && !type.IsInterface();
var settersReturnType = addPropertyAccessors && Config.SettersReturnThis ? typeName : null;
sb.AppendLine("public static {0} {1}{2}".Fmt(defType, typeName, extend));
sb.AppendLine("{");
sb = sb.Indent();
var addVersionInfo = Config.AddImplicitVersion != null && options.IsRequest;
if (addVersionInfo)
{
sb.AppendLine("public Integer {0} = {1};".Fmt("Version".PropertyStyle(), Config.AddImplicitVersion));
if (addPropertyAccessors)
sb.AppendPropertyAccessor("Integer", "Version", settersReturnType);
}
AddProperties(sb, type,
includeResponseStatus: Config.AddResponseStatus && options.IsResponse
&& type.Properties.Safe().All(x => x.Name != typeof(ResponseStatus).Name),
addPropertyAccessors: addPropertyAccessors,
settersReturnType: settersReturnType);
if (responseTypeExpression != null)
{
sb.AppendLine("private static Object responseType = {0};".Fmt(responseTypeExpression));
sb.AppendLine("public Object getResponseType() { return responseType; }");
}
sb = sb.UnIndent();
sb.AppendLine("}");
}
sb = sb.UnIndent();
return lastNS;
}
public void AddProperties(StringBuilderWrapper sb, MetadataType type,
bool includeResponseStatus,
bool addPropertyAccessors,
string settersReturnType)
{
var wasAdded = false;
var sbInner = StringBuilderCacheAlt.Allocate();
var sbAccessors = new StringBuilderWrapper(sbInner);
if (addPropertyAccessors)
{
sbAccessors.AppendLine();
sbAccessors = sbAccessors.Indent().Indent();
}
var dataMemberIndex = 1;
if (type.Properties != null)
{
foreach (var prop in type.Properties)
{
if (wasAdded) sb.AppendLine();
var propType = Type(prop.Type, prop.GenericArgs);
var fieldName = prop.Name.SafeToken().PropertyStyle();
var accessorName = fieldName.ToPascalCase();
wasAdded = AppendComments(sb, prop.Description);
wasAdded = AppendDataMember(sb, prop.DataMember, dataMemberIndex++) || wasAdded;
wasAdded = AppendAttributes(sb, prop.Attributes) || wasAdded;
if (!fieldName.IsKeyWord())
{
sb.AppendLine("public {0} {1} = null;".Fmt(propType, fieldName));
}
else
{
var originalName = fieldName;
fieldName = Char.ToUpper(fieldName[0]) + fieldName.SafeSubstring(1);
sb.AppendLine("@SerializedName(\"{0}\") public {1} {2} = null;".Fmt(originalName, propType, fieldName));
}
if (addPropertyAccessors)
sbAccessors.AppendPropertyAccessor(propType, fieldName, accessorName, settersReturnType);
}
}
if (includeResponseStatus)
{
if (wasAdded) sb.AppendLine();
AppendDataMember(sb, null, dataMemberIndex++);
sb.AppendLine("public ResponseStatus {0} = null;".Fmt(typeof(ResponseStatus).Name.PropertyStyle()));
if (addPropertyAccessors)
sbAccessors.AppendPropertyAccessor("ResponseStatus", "ResponseStatus", settersReturnType);
}
if (sbAccessors.Length > 0)
sb.AppendLine(StringBuilderCacheAlt.ReturnAndFree(sbInner).TrimEnd()); //remove last \n
}