private IClassItem ExtractSimpleItem(SimpleLeafInfo leaf)
{
string className = TypeDefTranslator.ResolveTypedef(leaf.TypeName);
//
// Check if it is a c-style array. If it is, then the title will contain
// the specification we need to look at for the c-style array bit. This will get
// called recursively to parse the actual type after the c-style array bit is stripped off.
//
if (leaf.Title.Contains("["))
{
return(ExtractCArrayInfo(leaf));
}
//
// Next, if the type is a template, special parse that.
//
var result = TemplateParser.ParseForTemplates(className);
if (result is TemplateParser.TemplateInfo)
{
return(ExtractTemplateItem(leaf, result as TemplateParser.TemplateInfo));
}
///
/// Ok - so it is a single "object" or similar. So we need to look at it and figure
/// out how to deal with it. It could be a root object or just an "int"
///
var ln = NormalizeLeafName(leaf.Name);
IClassItem toAdd = null;
if (IsROOTClass(className) && className != "string")
{
toAdd = new ItemROOTClass(ln, className);
}
else
{
toAdd = new ItemSimpleType(ln, className.SimpleCPPTypeToCSharpType());
}
if (toAdd == null || toAdd.ItemType == null)
{
throw new InvalidOperationException("Unknown type - can't translate '" + className + "'.");
}
return(toAdd);
}
public void GenerateClassFromClasses(
ClassGenerator target,
int outputChoice,
int numExtraFiles,
int numExtraFilesToCreate,
int extraFileIndexNull,
string nameSName,
int NumObjectCollection)
{
if (numExtraFiles < 0 ||
numExtraFilesToCreate < 0 ||
extraFileIndexNull < 0 ||
outputChoice < 0 ||
NumObjectCollection < 0)
{
return;
}
///
/// Kill off the directory we might have left behind from a previous run, and create a new one.
///
DirectoryInfo testDir = new DirectoryInfo(".\\GenerateClassFromClasses");
if (testDir.Exists)
{
testDir.Delete(true);
}
testDir.Create();
///
/// Setup the input stuff so Pex can play
///
FileInfo outputCSFile;
if (outputChoice == 1)
{
outputCSFile = new FileInfo(testDir.FullName + "\\output.cs");
}
else
{
outputCSFile = null;
}
ROOTClassShell[] objCollect = null;
if (NumObjectCollection > 0)
{
List <ROOTClassShell> objs = new List <ROOTClassShell>();
for (int i = 0; i < NumObjectCollection; i++)
{
ROOTClassShell rcs = new ROOTClassShell();
rcs.Name = "dude_" + i.ToString();
for (int j = 0; j < i; j++)
{
IClassItem item = null;
switch (NumObjectCollection % 4)
{
case 0:
item = null;
break;
case 1:
var itm = new ItemSimpleType()
{
ItemType = "int"
};
item = itm;
break;
case 2:
var itmv = new ItemVector()
{
ItemType = "int[]"
};
item = itmv;
break;
case 3:
var itmr = new ItemROOTClass()
{
ItemType = "TLorentzVector"
};
item = itmr;
break;
}
if (item != null)
{
item.Name = "item_" + j.ToString();
}
rcs.Items.Add(item);
}
objs.Add(rcs);
}
objCollect = objs.ToArray();
}
///
/// Create the final object, and any extra files needed!
///
NtupleTreeInfo info = new NtupleTreeInfo()
{
Classes = objCollect
};
info.ClassImplimintationFiles = (from c in Enumerable.Range(0, numExtraFiles)
let f = new FileInfo(testDir.FullName + "\\GenerateClassFromClasses_extra_" + c.ToString() + ".cpp")
select f.FullName
).ToArray();
int maxFilesToCreate = numExtraFilesToCreate > numExtraFiles ? numExtraFiles : numExtraFilesToCreate;
for (int i = 0; i < maxFilesToCreate; i++)
{
using (var w = File.CreateText(info.ClassImplimintationFiles[i]))
{
w.WriteLine();
w.Close();
}
}
if (extraFileIndexNull < numExtraFiles)
{
info.ClassImplimintationFiles[extraFileIndexNull] = null;
}
///
/// Ok, do the investigation
///
target.GenerateClasss(info, outputCSFile, nameSName);
Assert.IsFalse(info.ClassImplimintationFiles.Any(c => c == null), "no null implementation files allowed");
Assert.IsFalse(info.ClassImplimintationFiles.Any(c => !File.Exists(c)), "all implimntation files must exist");
/// Check that all the ntuple proxy guys and the temp file guys appear in the file
foreach (var item in info.ClassImplimintationFiles)
{
Assert.IsTrue(FindInFile(outputCSFile, item), "coul dnot find impl file '" + item + "'");
}
}