Esempio n. 1
0
        public void TestWithOneArray()
        {
            // We get memory corruption if we create the tree and use it, rather
            // than writing it out to a file first. Not sure why... GC and other
            // things looked at, but they don't seem to be variables.
            {
                var f = ROOTNET.NTFile.Open("TestWithOneArray.root", "RECREATE");
                var tree = CreateTrees.CreateTreeWithSimpleSingleVector(50);
                f.Write();
                f.Close();
            }

            var f1 = ROOTNET.NTFile.Open("TestWithOneArray.root", "READ");
            var tree1 = f1.Get("dude") as ROOTNET.NTTree;

            var aa = new ArrayAnalyzer();
            ROOTClassShell sh = new ROOTClassShell();
            sh.Add(new classitem() { ItemType = "int[]", Name = "myvectorofint" });
            var result = aa.DetermineAllArrayLengths(sh, tree1, 10);
            Assert.AreEqual(10, result.Length, "# of events");
            Assert.IsTrue(result.All(x => x.Length == 1), "incorrect individual variable list length list");
            Assert.IsTrue(result.All(x => x[0].Item2 == 10), "incorrect individual variable list length list");
            Assert.IsTrue(result.All(x => x[0].Item1 == "myvectorofint"), "incorrect individual variable list length list");
            f1.Close();
        }
Esempio n. 2
0
 public void TestWithNoArrays()
 {
     var aa = new ArrayAnalyzer();
     var tree = CreateTrees.CreateWithIntOnly(10);
     ROOTClassShell sh = new ROOTClassShell();
     var results = aa.DetermineAllArrayLengths(sh, tree, 10);
     Assert.AreEqual(1, results.Length, "# of events incorrect");
     Assert.AreEqual(0, results[0].Length, "found an array!?");
 }
Esempio n. 3
0
        public void TestArrayWithNoEntries()
        {
            ArrayAnalyzer target = new ArrayAnalyzer(); // TODO: Initialize to an appropriate value

            var tree = CreateTrees.CreateVectorTree();

            ROOTClassShell sh = new ROOTClassShell();

            target.DetermineAllArrayLengths(sh, tree, 10);
        }
Esempio n. 4
0
        /// <summary>
        /// Check to make sure that we can serialize everything.
        /// </summary>
        /// <param name="result"></param>
        private void CheckSerialization(ROOTClassShell[] result, string testName)
        {
            FileInfo outputFile = new FileInfo(testName + ".xml");
            XmlSerializer xmlTrans = new XmlSerializer(typeof(ROOTClassShell[]));

            using (var writer = outputFile.CreateText())
            {
                xmlTrans.Serialize(writer, result);
                writer.Close();
            }
        }
        public void TestNoGroups()
        {
            /// Create simple user info - but don't do anything with it!
            ItemSimpleType simple = new ItemSimpleType("var1", "int[]");
            Assert.IsFalse(simple.NotAPointer, "not a pointer");
            FileInfo proxyFile = new FileInfo("TestNoGroupsProxy.cpp");
            using (var writer = proxyFile.CreateText())
            {
                writer.WriteLine();
                writer.Close();
            }
            ROOTClassShell mainClass = new ROOTClassShell("TestSimpleRename") { NtupleProxyPath = proxyFile.FullName };
            mainClass.Add(simple);
            var ntup = new NtupleTreeInfo() { Classes = new ROOTClassShell[] { mainClass }, ClassImplimintationFiles = new string[0] };

            var userinfo = new TTreeUserInfo() { Groups = new ArrayGroup[] { new ArrayGroup() { Name = "ungrouped", Variables = new VariableInfo[] { new VariableInfo() { NETName = "var1", TTreeName = "var1" } } } } };

            var cg = new ClassGenerator();
            var outputFile = new FileInfo("TestNoGroups.cs");
            cg.GenerateClasss(ntup, outputFile, "junk", new Dictionary<string, TTreeUserInfo>() { { "TestSimpleRename", userinfo } });

            /// Look through this to see if we can make sure there are no renames!
            Assert.IsFalse(FindInFile(outputFile, "RenameVariable"), "We saw a rename!");
            Assert.IsFalse(FindInFile(outputFile, "ungrouped"), "group found");
        }
Esempio n. 6
0
        /// <summary>
        /// A class has been defined only in the local tree. We need to parse through it and extract
        /// enough into to build a class on our own so that it can be correctly referenced in LINQ.
        /// </summary>
        /// <param name="container"></param>
        /// <param name="branch"></param>
        /// <param name="cls"></param>
        /// <returns></returns>
        private IEnumerable<ROOTClassShell> BuildMetadataForTTreeClassFromBranches(ROOTClassShell container, ROOTNET.Interface.NTBranch branch, ROOTNET.Interface.NTClass cls)
        {
            //
            // Get a unique classname. Attempt to do "the right thing". In particular, if this is a clones array of some
            // struct, it is not a "named" class, so use the name of the clones array instead.
            //

            string className = cls.Name;
            bool mightBeClonesArray = false;
            if (branch is ROOTNET.Interface.NTBranchElement)
            {
                var cn = (branch as ROOTNET.Interface.NTBranchElement).ClonesName.SanitizedName();
                if (!string.IsNullOrWhiteSpace(cn))
                {
                    className = cn;
                    mightBeClonesArray = true;
                }
            }

            if (_classNameCounter.ContainsKey(className))
            {
                _classNameCounter[className] += 1;
                className = string.Format("{0}_{1}", className, _classNameCounter[className]);
            }
            else
            {
                _classNameCounter[className] = 0;
            }

            //
            // We will define the class, and it will be exactly what is given to use by the
            // tree.
            //

            var varName = branch.Name.SanitizedName();
            container.Add(new ItemSimpleType(varName, className) { NotAPointer = true });

            //
            // We are going to build our own class type here.
            //

            var treeClass = new ROOTClassShell(className) { IsTopLevelClass = false };

            //
            // Now, loop over the branches and add them in, returning any classes we had to generate.
            //

            foreach (var c in ExtractClassesFromBranchList(treeClass, branch.ListOfBranches.Cast<ROOTNET.Interface.NTBranch>()))
            {
                yield return c;
            }

            //
            // The arrays in a tclones arrays are funny. The proxy generated parses them as seperate arrays, but their length is
            // basically the size of the tclonesarray. So we have to use that as the length. This is implied be cause we've marked
            // this class as a tclones array class already (above - the IsTTreeSubClass). So for the index we mark it as an index,
            // but we just marked the bound as "implied" - this will be picked up by the code when it is generated later on.
            //

            if (mightBeClonesArray)
            {
                var cBoundName = string.Format("{0}_", varName);
                var cstyleArrayIndicies = from item in treeClass.Items
                                          where item is ItemCStyleArray
                                          let citem = item as ItemCStyleArray
                                          from index in citem.Indicies
                                          where !index.indexConst && index.indexBoundName == cBoundName
                                          select index;
                bool foundTClonesArray = false;
                foreach (var item in cstyleArrayIndicies)
                {
                    item.indexBoundName = "implied";
                    foundTClonesArray = true;
                }
                treeClass.IsTClonesArrayClass = foundTClonesArray;

            }

            //
            // If this is a tclones array - and it is a real array, then we don't want to de-reference anything.
            //

            if (treeClass.IsTClonesArrayClass)
            {
                foreach (var item in treeClass.Items)
                {
                    item.NotAPointer = true;
                }
            }

            //
            // Finally, the one we just built!
            //

            yield return treeClass;
        }
Esempio n. 7
0
        public void TestWithOneConstIndexedArray()
        {
            var aa = new ArrayAnalyzer();

            string filename = "TestWithOneConstIndexedArray.root";
            var f = new ROOTNET.NTFile(filename, "RECREATE");
            var tree = CreateTrees.CreateTreeWithConstIndexedSimpleVector(20);
            f.Write();

            ROOTClassShell sh = new ROOTClassShell();
            sh.Add(new classitem() { ItemType = "int[]", Name = "arr" });
            var result = aa.DetermineAllArrayLengths(sh, tree, 10);

            Assert.AreEqual(10, result.Length, "# of events");
            Assert.IsTrue(result.All(x => x.Length == 1), "# of arrays");
            Assert.IsTrue(result.All(x => x[0].Item2 == 20), "Length of array");
            Assert.IsTrue(result.All(x => x[0].Item1 == "arr"), "variable name");

            f.Close();
        }
        public void TestCStyleArrayBadIndexName()
        {
            // Simple set of types for an index array
            var vArray = new ItemCStyleArray("int[]", new ItemSimpleType("arr", "int"));
            vArray.Add(0, "i", false);
            var vIndex = new ItemSimpleType("n", "int");
            FileInfo proxyFile = new FileInfo("TestCStyleArray.cpp");
            using (var writer = proxyFile.CreateText())
            {
                writer.WriteLine();
                writer.Close();
            }
            ROOTClassShell mainClass = new ROOTClassShell("TestSimpleRename") { NtupleProxyPath = proxyFile.FullName };
            mainClass.Add(vIndex);
            mainClass.Add(vArray);
            var ntup = new NtupleTreeInfo() { Classes = new ROOTClassShell[] { mainClass }, ClassImplimintationFiles = new string[0] };

            var userinfo = new TTreeUserInfo()
            {
                Groups = new ArrayGroup[] { new ArrayGroup() {
                Name = "ungrouped",
                Variables = new VariableInfo[] {
                    new VariableInfo() { NETName = "n", TTreeName = "n" },
                    new VariableInfo() { NETName = "arr", TTreeName = "arr"}
                } } }
            };

            var cg = new ClassGenerator();
            var outputFile = new FileInfo("TestCStyleArray.cs");
            cg.GenerateClasss(ntup, outputFile, "junk", new Dictionary<string, TTreeUserInfo>() { { "TestSimpleRename", userinfo } });
        }
        public void TestRenamedIndex()
        {
            /// Create simple user info - but don't do anything with it!
            ItemSimpleType simpleIndex = new ItemSimpleType("index", "int[]");
            ItemSimpleType simpleVal = new ItemSimpleType("var1", "float[]");
            FileInfo proxyFile = new FileInfo("TestRenamedIndex.cpp");
            using (var writer = proxyFile.CreateText())
            {
                writer.WriteLine();
                writer.Close();
            }
            ROOTClassShell mainClass = new ROOTClassShell("TestRenamedIndex") { NtupleProxyPath = proxyFile.FullName };
            mainClass.Add(simpleIndex);
            mainClass.Add(simpleVal);
            var ntup = new NtupleTreeInfo() { Classes = new ROOTClassShell[] { mainClass }, ClassImplimintationFiles = new string[0] };

            var userinfo = new TTreeUserInfo()
            {
                Groups = new ArrayGroup[] {
                    new ArrayGroup()
                    {
                        Name = "jets", Variables = new VariableInfo[]
                        {
                            new VariableInfo() { NETName = "muons", TTreeName = "index", IndexToGroup="muons" }
                        }
                    },
                    new ArrayGroup()
                    {
                        Name = "muons", Variables = new VariableInfo[]
                        {
                            new VariableInfo() { NETName = "var1", TTreeName = "var1"}
                        }
                    }
                }
            };

            var cg = new ClassGenerator();
            var outputFile = new FileInfo("TestRenamedIndex.cs");
            cg.GenerateClasss(ntup, outputFile, "junk", new Dictionary<string, TTreeUserInfo>() { { "TestRenamedIndex", userinfo } });

            DumpOutputFile(outputFile);

            /// Look through this to see if we can make sure there are no renames!
            Assert.IsTrue(FindInFile(outputFile, "TTreeVariableGrouping"), "Missing TTreeVariableGrouping");
            Assert.IsTrue(FindInFile(outputFile, "jets"), "missing a reference to jets");
            Assert.IsTrue(FindInFile(outputFile, "muons"), "missing a reference to jets");
            Assert.IsTrue(FindInFile(outputFile, "IndexToOtherObjectArray(typeof("), "Missing IndexToOtherObject");
            Assert.IsTrue(FindInFile(outputFile, "TestRenamedIndexmuons muons"), "Muon reference is imporper");
            Assert.IsTrue(FindInFile(outputFile, "float var1"), "var1 missing");
            Assert.IsFalse(FindInFile(outputFile, "ungrouped"), "group found");
        }
Esempio n. 10
0
        public void GenerateClassFromClasses(
            ClassGenerator target,
            int outputChoice,
            int numExtraFiles,
            int numExtraFilesToCreate,
            int extraFileIndexNull,
            int proxyPathChoice,
            string nameSName,
            int NumObjectCollection)
        {
            if (numExtraFiles < 0
                || numExtraFilesToCreate < 0
                || extraFileIndexNull < 0
                || outputChoice < 0
                || proxyPathChoice < 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);
                }

                if (NumObjectCollection > 0)
                {
                    if (proxyPathChoice == 1)
                    {
                        var proxyFile = new FileInfo(testDir.FullName + "\\GenerateClassFromClasses_" + proxyPathChoice.ToString() + ".h");
                        using (var w = proxyFile.CreateText())
                        {
                            w.WriteLine("hi");
                            w.Close();
                        }
                        objs[0].NtupleProxyPath = proxyFile.FullName;
                    }

                    if (proxyPathChoice == 2)
                    {
                        var proxyFile = new FileInfo(testDir.FullName + "\\GenerateClassFromClasses_" + proxyPathChoice.ToString() + ".h");
                        objs[0].NtupleProxyPath = proxyFile.FullName;
                    }

                    if (proxyPathChoice == 3)
                    {
                        var proxyFile = new FileInfo(testDir.FullName + "\\GenerateClassFromClasses_" + proxyPathChoice.ToString() + ".h");
                        using (var w = proxyFile.CreateText())
                        {
                            w.WriteLine("hi");
                            w.Close();
                        }
                        foreach (var item in objs)
                        {
                            item.NtupleProxyPath = proxyFile.FullName;
                        }
                    }
                }
                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.Classes.Any(c => c.NtupleProxyPath == null), "No null proxy paths allowed");
            Assert.IsFalse(info.Classes.Any(c => !File.Exists(c.NtupleProxyPath)), "proxy files must exist");

            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.Classes.Where(c => c.IsTopLevelClass))
            {
                Assert.IsTrue(FindInFile(outputCSFile, item.NtupleProxyPath), "Could not find the proxy path '" + item.NtupleProxyPath + "'");
            }
            foreach (var item in info.ClassImplimintationFiles)
            {
                Assert.IsTrue(FindInFile(outputCSFile, item), "coul dnot find impl file '" + item + "'");
            }
        }
Esempio n. 11
0
        public void TestCharactersInClassName()
        {
            ItemSimpleType simple = new ItemSimpleType("fork", "int");
            FileInfo proxyFile = new FileInfo("TestColonsInVarName.cpp");
            using (var writer = proxyFile.CreateText())
            {
                writer.WriteLine();
                writer.Close();
            }

            ROOTClassShell mainClass = new ROOTClassShell("##Shapes") { NtupleProxyPath = proxyFile.FullName };
            mainClass.Add(simple);
            var ntup = new NtupleTreeInfo() { Classes = new ROOTClassShell[] { mainClass }, ClassImplimintationFiles = new string[0] };

            var userinfo = new TTreeUserInfo() { Groups = new ArrayGroup[] { new ArrayGroup() { Name = "jets", Variables = new VariableInfo[] { new VariableInfo() { NETName = "fork", TTreeName = "fork" } } } } };

            var cg = new ClassGenerator();
            var outputFile = new FileInfo("TestCharactersInClassName.cs");
            cg.GenerateClasss(ntup, outputFile, "junk", new Dictionary<string, TTreeUserInfo>() { { "TestSimpleGroupAndRename", userinfo } });

            DumpOutputFile(outputFile);

            Assert.AreEqual(3, CountInFile(outputFile, "##Shapes"), "Missing reference ot the shapes object");
        }
Esempio n. 12
0
        /// <summary>
        /// The class has no def in a TClass. It has no def in the way the branches and leaves are layed out. So,
        /// we, really, have only one option here. Parse the streamer!
        /// </summary>
        /// <param name="leaf"></param>
        /// <returns></returns>
        private IEnumerable<ROOTClassShell> ExtractUnsplitUnknownClass(ROOTClassShell container, string itemName, ROOTNET.Interface.NTClass cls)
        {
            // Make sure that we are ok here.
            var streamer = cls.StreamerInfo;
            if (streamer == null)
                return Enumerable.Empty<ROOTClassShell>();

            return ExtractClassFromStreamer(container, itemName, cls, streamer);
        }
Esempio n. 13
0
        /// <summary>
        /// Populate a class with the stuff we find in the branches we are looking at.
        /// </summary>
        /// <param name="container"></param>
        /// <param name="branches"></param>
        /// <returns></returns>
        private IEnumerable<ROOTClassShell> ExtractClassesFromBranchList(ROOTClassShell container, IEnumerable<ROOTNET.Interface.NTBranch> branches)
        {
            ///
            /// Now, loop through each branch and see if we can't convert everything!
            /// 

            foreach (var branch in branches)
            {
                ///
                /// What kind of branch is this? Is it a leaf branch or is it a "class" branch. That is, does it have
                /// sub leaves on it? The key question to ask is how many sub-branches are there here?
                /// 

                if (branch.ListOfBranches.Entries == 0)
                {
                    foreach (var leaf in branch.GetListOfLeaves().Cast<ROOTNET.Interface.NTLeaf>())
                    {
                        var cls = ROOTNET.NTClass.GetClass(leaf.TypeName);
                        if (cls == null || !cls.IsShellTClass() || cls.IsSTLClass())
                        {
                            // This is a class known to ROOT or
                            // it is something very simple (int, vector<int>, etc.).
                            try
                            {
                                IClassItem toAdd = ExtractUnsplitKnownClass(leaf);
                                if (toAdd != null)
                                    container.Add(toAdd);
                            }
                            catch (Exception e)
                            {
                                SimpleLogging.Log("Info: Unable to transltae ntuple leaf '" + leaf.Name + "': " + e.Message);
                            }
                        }
                        else
                        {
                            // This is a class we will have to bulid metadata for - from the streamer (the # of leaves
                            // is zero if we are here, so it can only be streamer defiend).

                            foreach (var item in ExtractUnsplitUnknownClass(container, leaf.Name, cls))
                                yield return item;
                        }
                    }
                }
                else
                {
                    var rc = ExtractClass(container, branch);
                    ROOTClassShell lastOne = null;
                    foreach (var rootClass in rc)
                    {
                        yield return rootClass;
                        lastOne = rootClass;
                    }
                }
            }
        }
Esempio n. 14
0
        /// <summary>
        /// Look at everything we have in this tree and see if we can't generate a class correctly.
        /// </summary>
        /// <param name="tree"></param>
        /// <returns></returns>
        public IEnumerable<ROOTClassShell> GenerateClasses(ROOTNET.Interface.NTTree tree)
        {
            if (tree == null)
                throw new ArgumentNullException("tree must not be null");

            ///
            /// The outlying class is going to be called by the name of the tree.
            /// 

            var masterClass = new ROOTClassShell(tree.Name);

            var subClassesByName = from sc in ExtractClassesFromBranchList(masterClass, tree.ListOfBranches.Cast<ROOTNET.Interface.NTBranch>())
                                   group sc by sc.Name;
            var subClasses = from scg in subClassesByName
                             where scg.ClassesAreIdnetical()
                             select scg.First();
            foreach (var sc in subClasses)
            {
                yield return sc;
            }


            ///
            /// Last thing we need to do is create a proxy for the class.
            /// 

            FileInfo f = MakeProxy(tree);
            masterClass.NtupleProxyPath = f.FullName;

            ///
            /// Work around a ROOT bug that doesn't allow for unloading of classes
            /// in the STL after a query is run. Actually, it will unload them, but somehow keeps
            /// references in memory.
            /// 

            masterClass.ClassesToGenerate = ExtractSTLDictionaryReferences(f);

            ///
            /// Analyze the TTree arrays.
            /// 

            var at = new ArrayAnalyzer();
            var groupInfo = at.AnalyzeTTree(masterClass, tree, 100);

            ///
            /// Any item that isn't an array should be added to the list and
            /// put in the "ungrouped" array.
            /// 

            AddNonArrays(masterClass, groupInfo, "ungrouped");

            ///
            /// Write out the user info
            /// 

            masterClass.UserInfoPath = WriteUserInfo(groupInfo, tree.SanitizedName()).FullName;

            ///
            /// Return the master class
            /// 

            yield return masterClass;
        }
Esempio n. 15
0
        /// <summary>
        /// Find all non-arrays and add them to our ungrouped group. Since this
        /// grouping is what drives the class generation, this is very much something
        /// we have to do! :-)
        /// </summary>
        /// <param name="masterClass"></param>
        /// <param name="groupToAddTo">What is the name of the group we should add them to?</param>
        private void AddNonArrays(ROOTClassShell masterClass, List<ArrayGroup> groups, string groupToAddTo)
        {
            ///
            /// First, get all non-arrays. Arrays are all declared with [] right now,
            /// so we need only look for that.
            /// 

            var nonarrays = (from item in masterClass.Items
                             where !item.ItemType.Contains("[]")
                             select item.Name).ToArray();
            if (nonarrays.Length == 0)
                return;

            ///
            /// Turn the names into variables
            /// 

            var varInfo = nonarrays.ToVariableInfo();

            ///
            /// See if the group we should add them to exists.
            ///

            var grp = (from g in groups
                       where g.Name == groupToAddTo
                       select g).FirstOrDefault();
            if (grp == null)
            {
                grp = new ArrayGroup() { Name = groupToAddTo, Variables = varInfo.ToArray() };
                groups.Add(grp);
            }
            else
            {
                grp.Variables = (grp.Variables.Concat(varInfo)).ToArray();
            }
        }
Esempio n. 16
0
        public void GroupWithArrayLengthSpecification()
        {
            ItemSimpleType simple1 = new ItemSimpleType("avar", "int[]");
            ItemSimpleType simple2 = new ItemSimpleType("bvar", "int[]");
            FileInfo proxyFile = new FileInfo("TestColonsInVarNameWRename.cpp");
            using (var writer = proxyFile.CreateText())
            {
                writer.WriteLine();
                writer.Close();
            }

            ROOTClassShell mainClass = new ROOTClassShell("GroupWithArrayLengthSpecification") { NtupleProxyPath = proxyFile.FullName };
            mainClass.Add(simple1);
            mainClass.Add(simple2);
            var ntup = new NtupleTreeInfo() { Classes = new ROOTClassShell[] { mainClass }, ClassImplimintationFiles = new string[0] };

            var userinfo = new TTreeUserInfo() { Groups = new ArrayGroup[] {
                new ArrayGroup() {
                    Name = "jets",
                    NETNameOfVariableToUseAsArrayLength ="b",
                    Variables = new VariableInfo[] {
                        new VariableInfo() { NETName = "a", TTreeName = "avar" },
                        new VariableInfo() { NETName = "b", TTreeName = "bvar" },
                    }
                } } };

            var cg = new ClassGenerator();
            var outputFile = new FileInfo("GroupWithArrayLengthSpecification.cs");
            cg.GenerateClasss(ntup, outputFile, "junk", new Dictionary<string, TTreeUserInfo>() { { "GroupWithArrayLengthSpecification", userinfo } });

            DumpOutputFile(outputFile);

            /// Look through this to see if we can make sure there are no renames!
            Assert.IsTrue(FindInFile(outputFile, "UseAsArrayLength"), "Missing the UseAsArrayLength attribute!!");
        }
Esempio n. 17
0
        public void TestColonsInVarName()
        {
            ItemSimpleType simple = new ItemSimpleType("dude::fork", "int[]");
            FileInfo proxyFile = new FileInfo("TestColonsInVarName.cpp");
            using (var writer = proxyFile.CreateText())
            {
                writer.WriteLine();
                writer.Close();
            }

            ROOTClassShell mainClass = new ROOTClassShell("TestSimpleGroupAndRename") { NtupleProxyPath = proxyFile.FullName };
            mainClass.Add(simple);
            var ntup = new NtupleTreeInfo() { Classes = new ROOTClassShell[] { mainClass }, ClassImplimintationFiles = new string[0] };

            var userinfo = new TTreeUserInfo() { Groups = new ArrayGroup[] { new ArrayGroup() { Name = "jets", Variables = new VariableInfo[] { new VariableInfo() { NETName = "dude::fork", TTreeName = "dude::fork" } } } } };

            var cg = new ClassGenerator();
            var outputFile = new FileInfo("TestSimpleGroupAndRename.cs");
            cg.GenerateClasss(ntup, outputFile, "junk", new Dictionary<string, TTreeUserInfo>() { { "TestSimpleGroupAndRename", userinfo } });

            DumpOutputFile(outputFile);

            /// Look through this to see if we can make sure there are no renames!
            Assert.IsFalse(FindInFile(outputFile, "dude::fork"), "Saw the double colon!!");
            Assert.IsTrue(FindInFile(outputFile, "dude__fork"), "Missing the variable!!");
        }
Esempio n. 18
0
        /// <summary>
        /// Extract a class from a "good" streamer.
        /// </summary>
        /// <param name="cls"></param>
        /// <param name="streamer"></param>
        /// <returns></returns>
        private IEnumerable<ROOTClassShell> ExtractClassFromStreamer(ROOTClassShell container, string itemName, ROOTNET.Interface.NTClass cls, ROOTNET.Interface.NTVirtualStreamerInfo sInfo)
        {
            // This guy is a class with elements, so go get the elements...

            var c = new ROOTClassShell(cls.Name.SanitizedName()) { IsTopLevelClass = false };
            if (container != null)
                container.Add(new ItemROOTClass() { Name = itemName, ItemType = cls.Name.SanitizedName(), NotAPointer = false });
            var clist = new List<ROOTClassShell>();
            clist.Add(c);

            foreach (var item in sInfo.Elements.Cast<ROOTNET.Interface.NTStreamerElement>())
            {
                if (item == null)
                    throw new ArgumentNullException("Streamer element was null");
                if (item.TypeName == "BASE")
                {
                    SimpleLogging.Log(string.Format("Item '{0}' has a subclass of type '{1}' - we can't parse inherritance yet", itemName, item.FullName));
                    continue;
                }
                var itemCls = item.ClassPointer;
                if (itemCls == null)
                {
                    // This is going to be something like "int", or totally unknown!
                    c.Add(ExtractSimpleItem(new SimpleLeafInfo() { Name = item.FullName, TypeName = item.TypeName, Title = item.FullName }));
                } else if (!itemCls.IsShellTClass())
                {
                    try
                    {
                        // We know about this class, and can use ROOT infrasturcutre to do the parsing for it.
                        // Protect against funny template arguments we can't deal with now - just skip them.
                        var itemC = ExtractSimpleItem(new SimpleLeafInfo() { Name = item.FullName, TypeName = itemCls.Name, Title = item.FullName });
                        c.Add(itemC);
                    }
                    catch (Exception e)
                    {
                        SimpleLogging.Log(string.Format("Unable to deal with streamer type '{0}', skiping member '{1}': {2}", itemCls.Name, item.FullName, e.Message));
                    }
                }
                else
                {
                    // Unknown to ROOT class. How we handle this, exactly, depends if it is a template class or if it is
                    // a raw class.
                    if (itemCls.IsTemplateClass())
                    {
                        var newClassDefs = ExtractROOTTemplateClass(c, item.FullName, itemCls.Name);
                        clist.AddRange(newClassDefs);
                    }
                    else
                    {
                        var newClassDefs = new List<ROOTClassShell>(ExtractUnsplitUnknownClass(c, item.FullName, itemCls));
                        clist.AddRange(newClassDefs);
                    }
                }
            }

            return clist;
        }
Esempio n. 19
0
        public void TestSimpleGroupWithCustomClassName()
        {
            /// Create simple user info - but don't do anything with it!
            ItemSimpleType simple = new ItemSimpleType("var1", "int[]");
            FileInfo proxyFile = new FileInfo("TestSimpleGroupAndRename.cpp");
            using (var writer = proxyFile.CreateText())
            {
                writer.WriteLine();
                writer.Close();
            }
            ROOTClassShell mainClass = new ROOTClassShell("TestSimpleGroupAndRename") { NtupleProxyPath = proxyFile.FullName };
            mainClass.Add(simple);
            var ntup = new NtupleTreeInfo() { Classes = new ROOTClassShell[] { mainClass }, ClassImplimintationFiles = new string[0] };

            var userinfo = new TTreeUserInfo() { Groups = new ArrayGroup[] { new ArrayGroup() { Name = "jets", ClassName = "Jet", Variables = new VariableInfo[] { new VariableInfo() { NETName = "myvar", TTreeName = "var1" } } } } };

            var cg = new ClassGenerator();
            var outputFile = new FileInfo("TestSimpleGroupAndRename.cs");
            cg.GenerateClasss(ntup, outputFile, "junk", new Dictionary<string, TTreeUserInfo>() { { "TestSimpleGroupAndRename", userinfo } });

            DumpOutputFile(outputFile);

            /// Look through this to see if we can make sure there are no renames!
            Assert.IsTrue(FindInFile(outputFile, "RenameVariable(\"var1\")"), "Rename missing!");
            Assert.IsTrue(FindInFile(outputFile, "TTreeVariableGrouping"), "Missing TTreeVariableGrouping");
            Assert.IsTrue(FindInFile(outputFile, "jets"), "missing a reference to jets");
            Assert.IsTrue(FindInFile(outputFile, "int myvar"), "myvar missing");
            Assert.IsTrue(FindInFile(outputFile, "int[] var1"), "val1 missing");
            Assert.IsFalse(FindInFile(outputFile, "ungrouped"), "group found");
            Assert.IsFalse(FindInFile(outputFile, "TestSimpleGroupAndRenamejets"), "Found the non-class name default class name");
            Assert.IsTrue(FindInFile(outputFile, "Jet"), "Did not find the Jet custom class name");
        }
Esempio n. 20
0
        /// <summary>
        /// Extract info for a sub-class from a branch! The last one is the top level class we are currently parsing!
        /// </summary>
        /// <param name="branch"></param>
        /// <returns></returns>
        private IEnumerable<ROOTClassShell> ExtractClass(ROOTClassShell container, ROOTNET.Interface.NTBranch branch)
        {
            ///
            /// First, figure out what kind of class this is. For example, might it be a stl vector? If so,
            /// then we need to parse that up!
            /// 

            if (branch.GetClassName().Contains("<"))
            {
                return ExtractROOTTemplateClass(container, branch);
            }
            else
            {
                return ExtractROOTPlainClass(container, branch);
            }
        }
Esempio n. 21
0
        public void TestNonIntIndex()
        {
            /// Create simple user info - but don't do anything with it!
            ItemSimpleType simpleIndex = new ItemSimpleType("index", "float[]");
            ItemSimpleType simpleVal = new ItemSimpleType("var1", "float[]");
            FileInfo proxyFile = new FileInfo("TestNonIntIndex.cpp");
            using (var writer = proxyFile.CreateText())
            {
                writer.WriteLine();
                writer.Close();
            }
            ROOTClassShell mainClass = new ROOTClassShell("TestNonIntIndex") { NtupleProxyPath = proxyFile.FullName };
            mainClass.Add(simpleIndex);
            mainClass.Add(simpleVal);
            var ntup = new NtupleTreeInfo() { Classes = new ROOTClassShell[] { mainClass }, ClassImplimintationFiles = new string[0] };

            var userinfo = new TTreeUserInfo()
            {
                Groups = new ArrayGroup[] {
                    new ArrayGroup()
                    {
                        Name = "jets", Variables = new VariableInfo[]
                        {
                            new VariableInfo() { NETName = "index", TTreeName = "index", IndexToGroup="muons" }
                        }
                    },
                    new ArrayGroup()
                    {
                        Name = "muons", Variables = new VariableInfo[]
                        {
                            new VariableInfo() { NETName = "var1", TTreeName = "var1"}
                        }
                    }
                }
            };

            var cg = new ClassGenerator();
            var outputFile = new FileInfo("TestNonIntIndex.cs");
            cg.GenerateClasss(ntup, outputFile, "junk", new Dictionary<string, TTreeUserInfo>() { { "TestNonIntIndex", userinfo } });
        }
Esempio n. 22
0
 /// <summary>
 /// Given a branch that is a template, parse it and add to the class hierarchy.
 /// </summary>
 /// <param name="branch"></param>
 /// <returns></returns>
 private IEnumerable<ROOTClassShell> ExtractROOTTemplateClass(ROOTClassShell container, ROOTNET.Interface.NTBranch branch)
 {
     return ExtractROOTTemplateClass(container, branch.Name, branch.GetClassName());
 }
Esempio n. 23
0
        public void TestConstCStyleArray()
        {
            // Simple set of types for an index array
            var vArray = new ItemCStyleArray("int[]", new ItemSimpleType("arr", "int"));
            vArray.Add(0, "10", true);
            var vIndex = new ItemSimpleType("n", "int");
            FileInfo proxyFile = new FileInfo("TestConstCStyleArray.cpp");
            using (var writer = proxyFile.CreateText())
            {
                writer.WriteLine();
                writer.Close();
            }

            ROOTClassShell mainClass = new ROOTClassShell("TestSimpleRename") { NtupleProxyPath = proxyFile.FullName };
            mainClass.Add(vIndex);
            mainClass.Add(vArray);
            var ntup = new NtupleTreeInfo() { Classes = new ROOTClassShell[] { mainClass }, ClassImplimintationFiles = new string[0] };

            var userinfo = new TTreeUserInfo()
            {
                Groups = new ArrayGroup[] { new ArrayGroup() {
                Name = "ungrouped",
                Variables = new VariableInfo[] {
                    new VariableInfo() { NETName = "n", TTreeName = "n" },
                    new VariableInfo() { NETName = "arr", TTreeName = "arr"}
                } } }
            };

            var cg = new ClassGenerator();
            var outputFile = new FileInfo("TestConstCStyleArray.cs");
            cg.GenerateClasss(ntup, outputFile, "junk", new Dictionary<string, TTreeUserInfo>() { { "TestSimpleRename", userinfo } });

            CopyToOutput(outputFile);

            /// Look through this to see if we can make sure there are no renames!
            Assert.IsTrue(FindInFile(outputFile, "int[] arr"), "Array Decl missing");
            Assert.IsTrue(FindInFile(outputFile, "int n"), "Index decl missing");
            Assert.IsTrue(FindInFile(outputFile, "[ArraySizeIndex(\"10\", IsConstantExpression = true, Index = 0)]"), "Missing array size index attribute");
        }
Esempio n. 24
0
        /// <summary>
        /// We extract the class info for a ROOT class that is a template. We properly deal with the class being templatized
        /// being another crazy class (or just a vector of int, etc.).
        /// </summary>
        /// <param name="container"></param>
        /// <param name="memberName"></param>
        /// <param name="className"></param>
        /// <returns></returns>
        private IEnumerable<ROOTClassShell> ExtractROOTTemplateClass(ROOTClassShell container, string memberName, string className)
        {
            ///
            /// Currently only setup to deal with some very specific types of vectors!
            /// 

            var parsedMatch = TemplateParser.ParseForTemplates(className) as TemplateParser.TemplateInfo;
            if (parsedMatch == null)
            {
                SimpleLogging.Log("Type '{0}' is a template, but we can't parse it, so '{1}' will be ignored", className, memberName);
                return Enumerable.Empty<ROOTClassShell>();
            }

            if (parsedMatch.TemplateName != "vector")
            {
                SimpleLogging.Log("We can only deal with the vector type (not '{0}'), so member '{1}' will be ignored", className, memberName);
                return Enumerable.Empty<ROOTClassShell>();
            }

            if (!(parsedMatch.Arguments[0] is TemplateParser.RegularDecl))
            {
                SimpleLogging.Log("We can't yet deal with nested templates - '{0}' - so member '{1}' will be ignored", className, memberName);
                return Enumerable.Empty<ROOTClassShell>();
            }

            var templateArgClass = (parsedMatch.Arguments[0] as TemplateParser.RegularDecl).Type;

            //
            // Now we take a look at the class.
            //
            // One case is that it is a simple class, like "Unsigned int" that
            // isn't known to root at all. That means we hvae no dictionary for vector<unsigned int> - otherwise
            // we never would have gotten into here. So ignore it. :-)
            // 

            var classInfo = ROOTNET.NTClass.GetClass(templateArgClass);
            if (classInfo == null)
                return Enumerable.Empty<ROOTClassShell>();

            //
            // If this class is known by root then we will have
            // a very easy time. No new classes are created or defined and there is nothing
            // extra to do other than making the element.
            
            if (!classInfo.IsShellTClass())
            {
                container.Add(new ItemVector(TemplateParser.TranslateToCSharp(parsedMatch), memberName));
                return Enumerable.Empty<ROOTClassShell>();
            }

            //
            // If the class isn't known by ROOT then we have only one hope - building it out of the
            // streamer (at this point, where we are in the code path, it is also the case that there
            // aren't leaf sub-branches here).
            //

            var newClassDefs = ExtractUnsplitUnknownClass(classInfo);
            container.Add(new ItemVector(TemplateParser.TranslateToCSharp(parsedMatch), memberName));
            return newClassDefs;
        }
Esempio n. 25
0
        public void TestDuplicateClassNames()
        {
            var vIndex = new ItemSimpleType("n", "int");
            FileInfo proxyFile = new FileInfo("TestCStyleArray.cpp");
            using (var writer = proxyFile.CreateText())
            {
                writer.WriteLine();
                writer.Close();
            }
            ROOTClassShell mainClass = new ROOTClassShell("TestSimpleRename") { NtupleProxyPath = proxyFile.FullName };
            mainClass.Add(vIndex);

            ROOTClassShell mainClass1 = new ROOTClassShell("TestSimpleRename") { NtupleProxyPath = proxyFile.FullName };
            mainClass1.Add(vIndex);
            var ntup = new NtupleTreeInfo() { Classes = new ROOTClassShell[] { mainClass, mainClass1 }, ClassImplimintationFiles = new string[0] };

            var userinfo = new TTreeUserInfo()
            {
                Groups = new ArrayGroup[] { new ArrayGroup() {
                Name = "ungrouped",
                Variables = new VariableInfo[] {
                    new VariableInfo() { NETName = "n", TTreeName = "n" },
                } } }
            };

            var cg = new ClassGenerator();
            var outputFile = new FileInfo("TestDuplicateClassNames.cs");
            cg.GenerateClasss(ntup, outputFile, "junk", new Dictionary<string, TTreeUserInfo>() { { "TestDuplicateClassNames", userinfo } });
        }
Esempio n. 26
0
        /// <summary>
        /// There is a plain class that needs to be extracted. We usually end up here becuase it is a split class of
        /// some sort. For now, we will assume it is a real root class.
        /// </summary>
        /// <param name="branch"></param>
        /// <returns></returns>
        private IEnumerable<ROOTClassShell> ExtractROOTPlainClass(ROOTClassShell container, ROOTNET.Interface.NTBranch branch)
        {
            //
            // Double chekc that this is a root class. Since we are looking at the Tree, ROOT's system would certianly have declared it
            // internally. If we can't find the cls info, then we are in trouble.
            // 

            var cls = ROOTNET.NTClass.GetClass(branch.GetClassName());
            if (cls == null)
            {
                throw new NotImplementedException("The class '" + branch.GetClassName() + "' is not known to ROOT's type systems - and I can't proceed unless it is");
            }
            if (cls.Name == "string")
            {
                throw new NotImplementedException("The class 'string' is not translated yet!");
            }

            //
            // There are several ways this class can be encoded in the file. They broadly break down
            // into two classes:
            //
            //  1) A class that is fully defined by ROOT. TLorentzVector would be such a thing.
            //      Custom classes that ROOT has a full dictionary for are equivalent and that
            //      we have a good wrapper for.
            //  2) A class that is only defined by the contents of the ROOT file. This could be
            //      as a series of leaves in the TTree (this would be the case of a split class)
            //      or in the streamer, which is a non-split class' case.
            //

            //
            // If it has some public data members, then it is a real ROOT class, and whatever was done to define it and make it known
            // to ROOT here we assume will also be done when the full blown LINQ interface is run (i.e. some loaded C++ files).
            //

            if (!cls.IsShellTClass())
            {
                container.Add(new ItemROOTClass(branch.Name, branch.GetClassName()));
                return Enumerable.Empty<ROOTClassShell>();
            }

            //
            // If we are here, then we are dealing with a locally defined class. One that ROOT made up on the fly. In short, not one
            // that we are going to have a translation for. So, we have to build the meta data for it. This
            // meta data can come from the tree branch list or from the streamer.
            //

            return BuildMetadataForTTreeClassFromBranches(container, branch, cls);
        }