private string DumpGDSManager(GDSTranslator.Input input, string nameSpaceName)
{
StringBuilder sb = new StringBuilder(partialGDSManager);
StringBuilder sbInitBlock = new StringBuilder();
StringBuilder sbGetter = new StringBuilder();
StringBuilder sbFileName = new StringBuilder();
int len = input.csvNames.Length;
int fileCount = 0;
for (int i = 0; i < len; ++i)
{
if (input.IsIgnored("csharp", input.csvNames[i]))
{
continue;
}
++fileCount;
AddFileName(sbFileName, input.csvNames[i]);
CSVParser.Output typeInfo = CSVParser.Parse(input.csvContents[i], CSVParser.PARSE_TYPE_INFO);
AddInitBlock(sbInitBlock, input.csvNames[i], fileCount - 1);
AddGDSGetter(sbGetter, input.csvNames[i], typeInfo);
}
sb.Replace(INIT_BLOCK_STUB, sbInitBlock.ToString());
sb.Replace(GDS_GETTER_STUB, sbGetter.ToString());
sb.Replace(FILE_NUMBER_STUB, fileCount.ToString());
sb.Replace(FILE_NAMES_STUB, sbFileName.ToString());
sb.Replace(NAMESPACE_STUB, nameSpaceName);
sb.Replace(QUOTE_STUB, "\"");
return(sb.ToString());
}
public Output Translate(Input input)
{
if (input.dstLanguageNames.Length != input.namespaceNames.Length)
{
throw new Exception("language and namespace length mismatch!");
}
if (input.csvNames.Length != input.csvContents.Length)
{
throw new Exception("csv file names and contents length mismatch!");
}
// precheck
foreach (string lng in input.dstLanguageNames)
{
if (!codeGenerators.ContainsKey(lng))
{
throw new Exception("unknown language : " + lng);
}
}
Output ret = new Output();
ret.codeFileNames = new Dictionary<string, List<string>>();
ret.codeFileContents = new Dictionary<string, List<string>>();
for(int i = 0; i < input.dstLanguageNames.Length; ++i)
{
string lng = input.dstLanguageNames[i];
string namespaceName = input.namespaceNames[i];
ILiteralGenerator generator = codeGenerators[lng];
List<string> fileNames = new List<string>();
List<string> fileContents = new List<string>();
for (int csvIdx = 0; csvIdx < input.csvNames.Length; ++csvIdx)
{
string csvFileName = input.csvNames[csvIdx];
if (input.IsIgnored(lng, csvFileName))
{
continue;
}
string csvFileContent = input.csvContents[csvIdx];
fileNames.Add(generator.GetCodeFileName(csvFileName));
CSVParser.Output csvResult = CSVParser.Parse(csvFileContent, CSVParser.PARSE_TYPE_INFO);
fileContents.Add(generator.GetCodeFileContent(csvFileName, namespaceName, csvResult));
}
ret.codeFileNames.Add(lng, fileNames);
ret.codeFileContents.Add(lng, fileContents);
}
return ret;
}
/*
* public Building GetBuilding(int id)
* {
* return Building.GetInstance(id);
* }
*/
private void AddGDSGetter(StringBuilder sb, string clsName, CSVParser.Output output)
{
string conj = ", ";
sb.Append("public ");
sb.Append(clsName);
sb.Append(" Get");
sb.Append(clsName);
sb.Append("(");
for (int i = 0; i < output.fieldMetaTypes.Length; ++i)
{
if (String.IsNullOrEmpty(output.isKeyFlags[i]))
{
continue;
}
sb.Append(output.fieldMetaTypes[i]);
sb.Append(" ");
sb.Append(output.fieldNames[i]);
sb.Append(conj);
}
sb.Remove(sb.Length - conj.Length, conj.Length);
sb.Append(")\n\t\t");
sb.Append("{\n\t\t\t");
sb.Append("return ");
sb.Append(clsName);
sb.Append(".GetInstance(");
for (int i = 0; i < output.fieldNames.Length; ++i)
{
if (String.IsNullOrEmpty(output.isKeyFlags[i]))
{
continue;
}
sb.Append(output.fieldNames[i]);
sb.Append(conj);
}
sb.Remove(sb.Length - conj.Length, conj.Length);
sb.Append(");\n\t\t");
sb.Append("}\n\t\t");
}
public string GetCodeFileContent(string clsName, string nameSpaceName, CSVParser.Output arg)
{
Console.WriteLine("Generating C# GDS code : " + clsName);
StreamReader fs = File.OpenText("../src/GDSTool/csharp.code");
string template = fs.ReadToEnd();
StringBuilder sb = new StringBuilder(template);
sb.Replace(NAMESPACE_STUB, nameSpaceName);
sb.Replace(CLASSNAME_STUB, clsName);
var contentStrings = MakeFileContentStrings(arg);
foreach (KeyValuePair <string, StringBuilder> kvp in contentStrings)
{
sb.Replace(kvp.Key, kvp.Value.ToString());
}
return(sb.ToString());
}
private Dictionary <string, StringBuilder> MakeFileContentStrings(CSVParser.Output arg)
{
var ret = new Dictionary <string, StringBuilder>()
{
{ FIELD_STUB, new StringBuilder() },
{ INITIALIZE_STUB, new StringBuilder() },
{ KEY_ARGS_STUB, new StringBuilder() },
{ KEY_COMBINER_STUB_WITH_THIS, new StringBuilder() },
{ KEY_COMBINER_STUB_WITHOUT_THIS, new StringBuilder() }
};
int len = arg.fieldMetaTypes.Length;
for (int i = 0; i < len; ++i)
{
string organizeType = arg.fieldOrganizeTypes[i];
string metaType = arg.fieldMetaTypes[i];
string fieldName = arg.fieldNames[i].ToLower();
bool isKey = !String.IsNullOrEmpty(arg.isKeyFlags[i]);
if (!isComposedType(metaType) && !metaTypeParsers.ContainsKey(metaType))
{
throw new Exception("unknown field meta type : " + metaType + ", fieldName : " + fieldName);
}
if ("Array" == organizeType)
{
AddArrayFieldDeclare(ret[FIELD_STUB], fieldName, metaType);
AddArrayFieldInitializer(ret[INITIALIZE_STUB], fieldName, metaType, i);
if (isKey)
{
throw new Exception("Error : array type can't be key!");
}
}
else if ("Meta" == organizeType)
{
AddMetaFieldDeclare(ret[FIELD_STUB], fieldName, metaType);
AddMetaFieldInitializer(ret[INITIALIZE_STUB], fieldName, metaType, i);
if (isKey)
{
AddKeyArg(ret[KEY_ARGS_STUB], fieldName, metaType);
AddKeyCombiner(ret[KEY_COMBINER_STUB_WITH_THIS], fieldName, metaType);
AddKeyCombiner2(ret[KEY_COMBINER_STUB_WITHOUT_THIS], fieldName, metaType);
}
}
else
{
throw new Exception("Unknown field compose type : " + organizeType);
}
}
if (String.IsNullOrEmpty(ret[KEY_ARGS_STUB].ToString()) ||
String.IsNullOrEmpty(ret[KEY_COMBINER_STUB_WITH_THIS].ToString()) ||
String.IsNullOrEmpty(ret[KEY_COMBINER_STUB_WITHOUT_THIS].ToString()))
{
throw new Exception("Invalid key config!");
}
Utils.TrimEnd(ret[KEY_ARGS_STUB], LITERAL_KEY_ARG_SEP.Length);
Utils.TrimEnd(ret[KEY_COMBINER_STUB_WITH_THIS], LITERAL_KEY_COMBINER_SEP.Length);
Utils.TrimEnd(ret[KEY_COMBINER_STUB_WITHOUT_THIS], LITERAL_KEY_COMBINER_SEP.Length);
return(ret);
}