private string GenerateFactoryMethod(TypeReference tr, string ownerNs)
{
StringWriter sw = new StringWriter();
Dictionary <string, string[]> cfm = ClassRenderer.CreateFactoryMethod(tr, "retVal", true);
if (tr.Class != null && tr.Class.IsAbstract)
{
foreach (var chld in tr.Class.SpecializedBy)
{
sw.WriteLine(GenerateFactoryMethod(chld, ownerNs));
}
}
else
{
string factoryName = String.Format("Create{0}", tr.Class.Name), tfact = factoryName;
if (generatedFactoryMethods.Contains(factoryName))
{
factoryName = String.Format("Create{0}", Util.Util.MakeFriendly(tr.Name));
}
generatedFactoryMethods.Add(factoryName);
// Iterate and create shortcuts
List <String> wroteParms = new List <string>(); // Keep track of the parameters used
foreach (KeyValuePair <String, String[]> kv in cfm)
{
if (kv.Value[0].Length == 0 || wroteParms.Contains(kv.Value[0]))
{
continue;
}
wroteParms.Add(kv.Value[0]);
// Correct generic children
// TODO: Turn these into regexes
//if (tr.Class.TypeParameters != null)
// for (int i = 0; i < tr.Class.TypeParameters.Count; i++)
// {
// List<TypeReference> filler = tr.GenericSupplier == null ? new List<TypeReference>() : tr.GenericSupplier.FindAll(o => (o as TypeParameter).ParameterName == tr.Class.TypeParameters[i].ParameterName);
// for(int f = 0; f< 2; f++)
// if (filler.Count == 1)
// foreach(string replacement in replaceMe)
// kv.Value[f] = kv.Value[f].Replace(String.Format(replacement, tr.Class.TypeParameters[i].ParameterName), String.Format(replacement, filler[0].Name));
// else
// foreach (string replacement in replaceMe)
// kv.Value[f] = kv.Value[f].Replace(String.Format(replacement, tr.Class.TypeParameters[i].ParameterName), String.Format(replacement, "System.Object"));
// }
// Generate method(s)
Class cls = tr.Class;
sw.WriteLine("\t\t/// <summary> Create a new instance of {0} to populate {1} </summary>", tr.Name, tr is TypeParameter ? (tr as TypeParameter).ParameterName : "");
sw.Write(kv.Value[2]);
sw.WriteLine("\t\tpublic static {0} {1} ({2}) {{ \r\n\t\t\t{0} retVal = new {0}();\r\n{3}", ClassRenderer.CreateDatatypeRef(tr, new Property()), factoryName,
kv.Value[0].Substring(0, kv.Value[0].Length - 1), kv.Value[1]);
sw.WriteLine("\t\t\treturn retVal;\r\n\t\t}");
if (!wroteParms.Contains(""))
{
wroteParms.Add("");
sw.WriteLine("\t\t/// <summary> Create a new instance of {0} to populate {1} </summary>", tr.Name, tr.Class.Name);
sw.WriteLine("\t\tpublic static {0} {1} () {{ \r\n\t\t\treturn new {0}();\r\n\t\t}}", ClassRenderer.CreateDatatypeRef(tr, new Property()), factoryName);
}
}
foreach (TypeReference tpr in tr.GenericSupplier ?? new List <TypeReference>())
{
sw.WriteLine(GenerateFactoryMethod(tpr, ownerNs));
}
}
return(sw.ToString());
}
/// <summary>
/// Get overridden setters
/// </summary>
public static SetterOverrideData[] GetOverrideSetters(TypeReference tr, Property p, string ownerPackage)
{
// Not a datatype so we won't need overrides
if (tr.Class != null)
{
return(new SetterOverrideData[0]);
}
// Get all the setter overrides
var dataType = s_heuristicData.Datatypes.Find(o => o.MifDatatype == tr.Name);
// Sanity check
if (dataType == null || dataType.SetterOverride.Count == 0)
{
return(new SetterOverrideData[0]);
}
// Set generic paramaters
Dictionary <String, String> bind = new Dictionary <string, string>();
string fillParameter = dataType.TemplateParameter;
if (!String.IsNullOrEmpty(dataType.TemplateParameter))
{
int i = 0;
foreach (string s in dataType.TemplateParameter.Split(','))
{
TypeReference bindTypeRef = null;
if (tr.GenericSupplier != null) // Generic Supplier
{
bindTypeRef = tr.GenericSupplier.Find(o => o is TypeParameter && (o as TypeParameter).ParameterName == s);
if (bindTypeRef == null)
{
bindTypeRef = tr.GenericSupplier[i++];
}
}
else if (p != null && p.SupplierDomain != null && !String.IsNullOrEmpty(EnumerationRenderer.WillRender(p.SupplierDomain)))
{
string vocabName = Util.Util.MakeFriendly(EnumerationRenderer.WillRender(p.SupplierDomain));
string containerName = p.Container is Choice ? (p.Container as Choice).Container.Name : p.Container.Name;
if (vocabName.Equals(containerName))
{
vocabName = String.Format("{0}.vocabulary.{1}", ownerPackage, vocabName);
}
bindTypeRef = new TypeReference()
{
Name = String.Format("{0}", vocabName)
};
}
else
{
bindTypeRef = new TypeReference()
{
Name = dataType.DefaultBind
}
};
// Add Binding
bind.Add(s, ClassRenderer.CreateDatatypeRef(bindTypeRef ?? new TypeReference()
{
Name = null
}, null, ownerPackage));
fillParameter = fillParameter.Replace(s, bind[s]);
}
}
// Create setter override and return
List <SetterOverrideData> overrides = new List <SetterOverrideData>(dataType.SetterOverride.Count);
foreach (var sod in dataType.SetterOverride)
{
// Correct parameters
SetterOverrideData templatedSod = new SetterOverrideData();
templatedSod.Parameters = new List <PropertyInfoData>();
foreach (var parameterData in sod.Parameters)
{
string dt = String.Empty;
if (!bind.TryGetValue(parameterData.DataType, out dt))
{
dt = parameterData.DataType;
}
templatedSod.Parameters.Add(new PropertyInfoData()
{
Name = parameterData.Name, DataType = dt.Replace(string.Format("<{0}>", dataType.TemplateParameter), String.Format("<{0}>", fillParameter))
});
}
// Correct Body
templatedSod.Throws = new List <ThrowsData>(sod.Throws);
templatedSod.SetterText = sod.SetterText.Replace(string.Format("<{0}>", dataType.TemplateParameter), String.Format("<{0}>", fillParameter));
templatedSod.ValueInstance = sod.ValueInstance;
overrides.Add(templatedSod);
}
return(overrides.ToArray());
}