public static BaijiType BuildFieldType(ParseTreeNode fieldTypeNode)
{
BaijiType type = null;
var fieldTypeChildNode = fieldTypeNode.ChildNodes[0];
if (fieldTypeChildNode.Term.Name == IdlGrammar.TNAME_TIDENTIFIER)
{
var identifier = fieldTypeChildNode.Token.Text;
type = new IdentifierType(identifier);
}
else if (fieldTypeChildNode.Term.Name == IdlGrammar.NTNAME_TBASE_TYPE)
{
var baseTypeKeyword = fieldTypeChildNode.FindTokenAndGetText();
var bType = ConvertBaseTypeKeywordToBaseType(baseTypeKeyword);
type = new BaseType(bType);
}
else if (fieldTypeChildNode.Term.Name == IdlGrammar.NTNAME_TCONTAINER_TYPE)
{
var containerTypeNode = fieldTypeChildNode.ChildNodes[0];
if (containerTypeNode.Term.Name == IdlGrammar.NTNAME_TMAP_TYPE)
{
var keyType = BuildMapKeyType(containerTypeNode.ChildNodes[0]);
var valueType = BuildFieldType(containerTypeNode.ChildNodes[1]);
type = new MapType(keyType, valueType);
}
else if (containerTypeNode.Term.Name == IdlGrammar.NTNAME_TLIST_TYPE)
{
var listValueType = BuildFieldType(containerTypeNode.ChildNodes[0]);
type = new ListType(listValueType);
}
}
return(type);
}
public string ConvertToString(BaijiType type, bool nullable)
{
var listType = type as ListType;
string actualType = typeToJavaConverter.ConvertToString(listType.Type, false);
return("List<" + actualType + ">");
}
public string ConvertToString(BaijiType type)
{
var listType = type as ListType;
string actualType = typeToCSharpConverter.ConvertToString(listType.Type);
return("List<" + actualType + ">");
}
public string ConvertToString(BaijiType type, bool nullable)
{
var listType = type as ListType;
string actualType = typeToOCConverter.ConvertToString(listType.Type, false);
return("NSArray");
}
public BaijiField(string[] docStringLines, string name, BaijiType type, Required required,
IList <Annotation> annotations)
{
DocStringLines = docStringLines;
Name = Enforce.IsNotNull(name, "name");
Type = Enforce.IsNotNull(type, "type");
Required = required;
Annotations = annotations;
}
public GenType ConvertToGenType(BaijiType type)
{
var csharpTypeName = ConvertToString(type);
var baseType = ((BaseType)type).BType;
var gType = GTYPE_BASETYPE_MAP[baseType];
var genType = new GenType(gType, csharpTypeName);
return(genType);
}
public string ConvertToString(BaijiType type)
{
var mapType = type as MapType;
string actualKeyType = typeToCSharpConverter.ConvertToString(mapType.KeyType);
string actualValueType = typeToCSharpConverter.ConvertToString(mapType.ValueType);
return(string.Format("Dictionary<{0}, {1}>", actualKeyType, actualValueType));
}
public string ConvertToString(BaijiType type, bool nullable)
{
var mapType = type as MapType;
string actualKeyType = typeToJavaConverter.ConvertToString(mapType.KeyType, false);
string actualValueType = typeToJavaConverter.ConvertToString(mapType.ValueType, false);
return(string.Format("Map<{0}, {1}>", actualKeyType, actualValueType));
}
public GenType ConvertToGenType(BaijiType type, bool nullable)
{
var ocTypeName = ConvertToString(type, nullable);
var baseType = ((BaseType)type).BType;
var gType = GTYPE_BASETYPE_MAP[baseType];
var genType = new GenType(gType, ocTypeName);
return(genType);
}
public static List <BaijiField> BuildFields(ParseTreeNode fieldNodes, string structName)
{
var fields = new List <BaijiField>();
foreach (var fieldNode in fieldNodes.ChildNodes)
{
string[] docStringLines = null;
string fieldName = null;
Required fieldReq = Required.NONE;
BaijiType fieldType = null;
IList <Annotation> annotations = null;
foreach (var fieldChildNode in fieldNode.ChildNodes)
{
if (fieldChildNode.Term.Name == IdlGrammar.NTNAME_TDOCSTRINGOREMPTY &&
fieldChildNode.ChildNodes.Count > 0)
{
docStringLines = ParseDocStringLines(fieldChildNode.ChildNodes[0].FindTokenAndGetText());
}
else if (fieldChildNode.Term.Name == IdlGrammar.NTNAME_FIELD_REQ &&
fieldChildNode.ChildNodes.Count > 0)
{
var fieldReqText = fieldChildNode.ChildNodes[0].FindTokenAndGetText();
if (fieldReqText == "required")
{
fieldReq = Required.REQUIRED;
}
else if (fieldReqText == "optional")
{
fieldReq = Required.OPTIONAL;
}
else
{
fieldReq = Required.NONE;
}
}
else if (fieldChildNode.Term.Name == IdlGrammar.NTNAME_TFIELD_TYPE)
{
fieldType = BuildFieldType(fieldChildNode);
}
else if (fieldChildNode.Term.Name == IdlGrammar.TNAME_TIDENTIFIER)
{
fieldName = fieldChildNode.Token.Text;
}
else if (fieldChildNode.Term.Name == IdlGrammar.NTNAME_TANNOTATIONSOREMPTY &&
fieldChildNode.ChildNodes.Count > 0)
{
annotations = BuildAnnotations(fieldChildNode.ChildNodes);
}
}
var field = new BaijiField(docStringLines, fieldName, fieldType, fieldReq, annotations);
fields.Add(field);
}
return(fields);
}
public string ConvertToString(BaijiType type, bool nullable)
{
var codeType = FindCodeTypeFromIdentifierType((IdentifierType)type);
var className = ShortenClassName(codeType.FullName);
if (codeType.IsEnum && nullable)
{
className += "?";
}
return(className);
}
public GenType ConvertToGenType(BaijiType type, bool nullable)
{
var javaTypeName = ConvertToString(type, nullable);
var listType = type as ListType;
var genType = new GenType(GenType.Type.List, javaTypeName);
genType.ElementType = typeToOCConverter.ConvertToGenType(listType.Type, false);
genType.ElementTypeName = typeToOCConverter.ConvertToString(listType.Type, false);
return(genType);
}
public GenType ConvertToGenType(BaijiType type)
{
var csharpTypeName = ConvertToString(type);
var listType = type as ListType;
var genType = new GenType(GType.List, csharpTypeName);
genType.ElementType = typeToCSharpConverter.ConvertToGenType(listType.Type);
genType.ElementCSharpTypeName = typeToCSharpConverter.ConvertToString(listType.Type);
return(genType);
}
public GenType ConvertToGenType(BaijiType type)
{
var javaTypeName = ConvertToString(type);
var listType = type as ListType;
var genType = new GenType(GType.List, javaTypeName);
genType.ElementType = typeToJavaConverter.ConvertToGenType(listType.Type);
genType.ElementJavaTypeName = typeToJavaConverter.ConvertToString(listType.Type);
return(genType);
}
public GenType ConvertToGenType(BaijiType tripType)
{
foreach (var converter in converters)
{
if (converter.Accept(tripType))
{
return(converter.ConvertToGenType(tripType));
}
}
throw new ArgumentException(string.Format("Trip type {0} is unknown!", tripType));
}
public string ConvertToString(BaijiType type)
{
var csharpType = this.FindCSharpTypeFromIdentifierType((IdentifierType)type);
var clzName = ShortenClassName(csharpType.TypeFullName);
if (csharpType.IsTripEnum)
{
clzName += "?";
}
return(clzName);
}
public GenType ConvertToGenType(BaijiType type, bool nullable = true)
{
foreach (var converter in _converters)
{
if (converter.Accept(type))
{
return(converter.ConvertToGenType(type, nullable));
}
}
throw new ArgumentException(string.Format("Baiji type {0} is unknown!", type));
}
public GenType ConvertToGenType(BaijiType type)
{
var csharpTypeName = ConvertToString(type);
var mapType = type as MapType;
var genType = new GenType(GType.Map, csharpTypeName);
genType.KeyType = typeToCSharpConverter.ConvertToGenType(mapType.KeyType);
genType.KeyCSharpTypeName = typeToCSharpConverter.ConvertToString(mapType.KeyType);
genType.ValueType = typeToCSharpConverter.ConvertToGenType(mapType.ValueType);
genType.ValueCSharpTypeName = typeToCSharpConverter.ConvertToString(mapType.ValueType);
return(genType);
}
public GenType ConvertToGenType(BaijiType type)
{
var javaTypeName = ConvertToString(type);
var mapType = type as MapType;
var genType = new GenType(GType.Map, javaTypeName);
genType.KeyType = typeToJavaConverter.ConvertToGenType(mapType.KeyType);
genType.KeyJavaTypeName = typeToJavaConverter.ConvertToString(mapType.KeyType);
genType.ValueType = typeToJavaConverter.ConvertToGenType(mapType.ValueType);
genType.ValueJavaTypeName = typeToJavaConverter.ConvertToString(mapType.ValueType);
return(genType);
}
public GenType ConvertToGenType(BaijiType type, bool nullable)
{
var javaTypeName = ConvertToString(type, nullable);
var mapType = type as MapType;
var genType = new GenType(GenType.Type.Map, javaTypeName);
genType.KeyType = typeToOCConverter.ConvertToGenType(mapType.KeyType, false);
genType.KeyTypeName = typeToOCConverter.ConvertToString(mapType.KeyType, false);
genType.ValueType = typeToOCConverter.ConvertToGenType(mapType.ValueType, false);
genType.ValueTypeName = typeToOCConverter.ConvertToString(mapType.ValueType, false);
return(genType);
}
public GenType ConvertToGenType(BaijiType type)
{
var javaTypeName = ConvertToString(type);
var javaType = this.FindJavaTypeFromIdentifierType((IdentifierType)type);
if (javaType.IsLeanEnum)
{
return(new GenType(GType.Enum, javaTypeName));
}
else
{
return(new GenType(GType.Struct, javaTypeName));
}
}
public GenType ConvertToGenType(BaijiType type)
{
var csharpTypeName = ConvertToString(type);
var csharpType = this.FindCSharpTypeFromIdentifierType((IdentifierType)type);
if (csharpType.IsTripEnum)
{
return(new GenType(GType.Enum, csharpTypeName));
}
else
{
return(new GenType(GType.Struct, csharpTypeName));
}
}
public GenType ConvertToGenType(BaijiType type, bool nullable)
{
var javaTypeName = ConvertToString(type, nullable);
var javaType = FindCodeTypeFromIdentifierType((IdentifierType)type);
if (javaType.IsEnum)
{
return(new GenType(GenType.Type.Enum, javaTypeName));
}
else
{
return(new GenType(GenType.Type.Struct, javaTypeName));
}
}
private void VisitType(BaijiType type)
{
if (type is IdentifierType)
{
Visit((IdentifierType)type);
}
else if (type is BaseType)
{
Visit((BaseType)type);
}
else if (type is ListType)
{
Visit((ListType)type);
}
else if (type is MapType)
{
Visit((MapType)type);
}
}
private void FindDefNameByType(BaijiType type, out string structName)
{
structName = null;
if (type.GetType() == typeof(BaseType))
{
return;
}
if (type.GetType() == typeof(ListType))
{
FindDefNameByType(((ListType)type).Type, out structName);
return;
}
if (type.GetType() == typeof(MapType))
{
FindDefNameByType(((MapType)type).ValueType, out structName);
return;
}
if (type.GetType() == typeof(IdentifierType))
{
structName = ((IdentifierType)type).Name;
return;
}
}
private Schema.Schema BuildSchema(string @namespace, BaijiType type, IDictionary <SchemaName, Schema.Schema> parsedSchema)
{
if (type is BaseType)
{
var baseType = (BaseType)type;
return(new PrimitiveSchema(_bTypeMapping[baseType.BType], null));
}
if (type is ListType)
{
var listType = (ListType)type;
var itemSchema = BuildSchema(@namespace, listType.Type, parsedSchema);
return(new ArraySchema(itemSchema, null));
}
if (type is MapType)
{
var mapType = (MapType)type;
var valueSchema = BuildSchema(@namespace, mapType.ValueType, parsedSchema);
return(new MapSchema(valueSchema, null));
}
if (type is IdentifierType)
{
var idType = (IdentifierType)type;
string name = idType.Name;
if (@namespace != _typeConverter.IdlNamespace && !name.Contains("."))
{
name = @namespace + "." + name;
}
var codeType = _typeConverter.FindCodeTypeFromName(name);
return(BuildSchema(codeType, parsedSchema));
}
throw new NotSupportedException("Unknown BaijiType: " + type);
}
public MapType(BaijiType keyType, BaijiType valueType)
{
KeyType = Enforce.IsNotNull(keyType, "keyType");
ValueType = Enforce.IsNotNull(valueType, "valueType");
}
public string ConvertToString(BaijiType type)
{
var baseType = ((BaseType)type).BType;
return(CSHARP_PRIMITIVES_MAP[baseType]);
}
public bool Accept(BaijiType type)
{
return(type.GetType() == typeof(BaseType));
}
public bool Accept(BaijiType type)
{
return(type.GetType() == typeof(IdentifierType));
}
