[tree] major and minor indices to 64bit, the 32bit were remnants from old legacy interface

Fixes https://its.cern.ch/jira/browse/ROOT-9028

[treeindex] print error when requesting out of bonds combination

31bit restriction was old, now they have separate 64-bit registers

better document old2new

Author: ferdymercury

tree/tree/inc/TChain.h

@@ -101,7 +101,7 @@ class TChain : public TTree {
    Long64_t  GetEntries(const char *sel) override { return TTree::GetEntries(sel); }
    Int_t     GetEntry(Long64_t entry=0, Int_t getall=0) override;
    Long64_t  GetEntryNumber(Long64_t entry) const override;
-   Int_t     GetEntryWithIndex(Int_t major, Int_t minor=0) override;
+   Int_t     GetEntryWithIndex(Long64_t major, Long64_t minor=0) override;
    TFile            *GetFile() const;
    TLeaf    *GetLeaf(const char* branchname, const char* leafname) override;
    TLeaf    *GetLeaf(const char* name) override;

tree/tree/inc/TTree.h

@@ -467,7 +467,7 @@ class TTree : public TNamed, public TAttLine, public TAttFill, public TAttMarker
    virtual Long64_t        GetEstimate() const { return fEstimate; }
    virtual Int_t           GetEntry(Long64_t entry, Int_t getall = 0);
            Int_t           GetEvent(Long64_t entry, Int_t getall = 0) { return GetEntry(entry, getall); }
-   virtual Int_t           GetEntryWithIndex(Int_t major, Int_t minor = 0);
+   virtual Int_t           GetEntryWithIndex(Long64_t major, Long64_t minor = 0);
    virtual Long64_t        GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor = 0) const;
    virtual Long64_t        GetEntryNumberWithIndex(Long64_t major, Long64_t minor = 0) const;
    TEventList             *GetEventList() const { return fEventList; }

tree/tree/src/TChain.cxx

@@ -1023,13 +1023,13 @@ Long64_t TChain::GetEntryNumber(Long64_t entry) const
 ////////////////////////////////////////////////////////////////////////////////
 /// Return entry corresponding to major and minor number.
 ///
-/// The function returns the total number of bytes read.
+/// The function returns the total number of bytes read; -1 if entry not found.
 /// If the Tree has friend trees, the corresponding entry with
 /// the index values (major,minor) is read. Note that the master Tree
 /// and its friend may have different entry serial numbers corresponding
 /// to (major,minor).
 
-Int_t TChain::GetEntryWithIndex(Int_t major, Int_t minor)
+Int_t TChain::GetEntryWithIndex(Long64_t major, Long64_t minor)
 {
    Long64_t serial = GetEntryNumberWithIndex(major, minor);
    if (serial < 0) return -1;

tree/tree/src/TTree.cxx

@@ -5919,13 +5919,13 @@ Long64_t TTree::GetEntryNumberWithIndex(Long64_t major, Long64_t minor) const
 ////////////////////////////////////////////////////////////////////////////////
 /// Read entry corresponding to major and minor number.
 ///
-///  The function returns the total number of bytes read.
+///  The function returns the total number of bytes read; -1 if entry not found.
 ///  If the Tree has friend trees, the corresponding entry with
 ///  the index values (major,minor) is read. Note that the master Tree
 ///  and its friend may have different entry serial numbers corresponding
 ///  to (major,minor).
 
-Int_t TTree::GetEntryWithIndex(Int_t major, Int_t minor)
+Int_t TTree::GetEntryWithIndex(Long64_t major, Long64_t minor)
 {
    // We already have been visited while recursively looking
    // through the friends tree, let's return.

tree/treeplayer/src/TTreeIndex.cxx

@@ -315,8 +315,11 @@ void TTreeIndex::Append(const TVirtualIndex *add, bool delaySort )
 
 
 ////////////////////////////////////////////////////////////////////////////////
-/// conversion from old 64bit indexes
-/// return true if index was converted
+/// Conversion from old 64bit indexes.
+/// Before, major and minor were stored as a single 64-bit register, with
+/// bits [0,30] for minor and bits [31,64] for major.
+/// Now, both minor and major have their own 64-bit register.
+/// \return true if index was converted
 
 bool TTreeIndex::ConvertOldToNew()
 {
@@ -339,6 +342,7 @@ bool TTreeIndex::ConvertOldToNew()
 /// In case this (friend) Tree and 'master' do not share an index with the same
 /// major and minor name, the entry serial number in the (friend) tree
 /// and in the master Tree are assumed to be the same
+/// \note An internal (intermediate) cast to double before storage as Long64_t
 
 Long64_t TTreeIndex::GetEntryNumberFriend(const TTree *parent)
 {
@@ -401,8 +405,8 @@ Long64_t TTreeIndex::FindValues(Long64_t major, Long64_t minor) const
 /// Return entry number corresponding to major and minor number.
 /// Note that this function returns only the entry number, not the data
 /// To read the data corresponding to an entry number, use TTree::GetEntryWithIndex
-/// the BuildIndex function has created a table of Double_t* of sorted values
-/// corresponding to val = major<<31 + minor;
+/// the BuildIndex function has created two tables of Long64_t sorted values
+/// (with an internal intermediate cast to LongDouble)
 /// The function performs binary search in this sorted table.
 /// If it finds a pair that maches val, it returns directly the
 /// index in the table.
@@ -416,7 +420,6 @@ Long64_t TTreeIndex::FindValues(Long64_t major, Long64_t minor) const
 Long64_t TTreeIndex::GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor) const
 {
    if (fN == 0) return -1;
-
    Long64_t pos = FindValues(major, minor);
    if( pos < fN && fIndexValues[pos] == major && fIndexValuesMinor[pos] == minor )
       return fIndex[pos];
@@ -430,8 +433,8 @@ Long64_t TTreeIndex::GetEntryNumberWithBestIndex(Long64_t major, Long64_t minor)
 /// Return entry number corresponding to major and minor number.
 /// Note that this function returns only the entry number, not the data
 /// To read the data corresponding to an entry number, use TTree::GetEntryWithIndex
-/// the BuildIndex function has created a table of Double_t* of sorted values
-/// corresponding to val = major<<31 + minor;
+/// the BuildIndex function has created two tables of Long64_t sorted values
+/// (with an internal intermediate cast to LongDouble)
 /// The function performs binary search in this sorted table.
 /// If it finds a pair that maches val, it returns directly the
 /// index in the table, otherwise it returns -1.