Esempio n. 1
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. 2
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. 3
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>
            {
                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);
        }