class TTreeFormula: public ROOT::v5::TFormula

 Tree Formula default constructor

 Normal TTree Formula Constuctor

 Constructor used during the expansion of an alias

 Initialiation called from the constructors.

Tree Formula default destructor
*-*                  =================================

 This method is used internally to decode the dimensions of the variables

 This method is used internally to decode the dimensions of the variables

 This method stores the dimension information for later usage.

 This method is used internally to decode the dimensions of the variables

 This method is used internally to decode the dimensions of the variables

 This method is used internally to decode the dimensions of the variables

 This method check for treat the case where expression contains $Atl and load up
 both fAliases and fExpr.
 We return
   -1 in case of failure
   0 in case we did not find $Alt
   the action number in case of success.

 Decompose 'expression' as pointing to something inside the leaf
 Returns:
   -2  Error: some information is missing (message already printed)
   -1  Error: Syntax is incorrect (message already printed)
    0
    >0 the value returns is the action code.

 Look for the leaf corresponding to the start of expression.
 It returns the corresponding leaf if any.
 It also modify the following arguments:
   leftover: contain from expression that was not used to determine the leaf
   final:
   paran_level: number of un-matched open parenthesis
   cast_queue: list of cast to be done
   aliases: list of aliases used
 Return <0 in case of failure
 Return 0 if a leaf has been found
 Return 2 if info about the TTree itself has been requested.

-*Check if name is in the list of Tree/Branch leaves
*-*        ==================================================

   This member function redefines the function in ROOT::v5::TFormula
   If a leaf has a name corresponding to the argument name, then
   returns a new code.
   A TTreeFormula may contain more than one variable.
   For each variable referenced, the pointers to the corresponding
   branch and leaf is stored in the object arrays fBranches and fLeaves.

   name can be :
      - Leaf_Name (simple variable or data member of a ClonesArray)
      - Branch_Name.Leaf_Name
      - Branch_Name.Method_Name
      - Leaf_Name[index]
      - Branch_Name.Leaf_Name[index]
      - Branch_Name.Leaf_Name[index1]
      - Branch_Name.Leaf_Name[][index2]
      - Branch_Name.Leaf_Name[index1][index2]
   New additions:
      - Branch_Name.Leaf_Name[OtherLeaf_Name]
      - Branch_Name.Datamember_Name
      - '.' can be replaced by '->'
   and
      - Branch_Name[index1].Leaf_Name[index2]
      - Leaf_name[index].Action().OtherAction(param)
      - Leaf_name[index].Action()[val].OtherAction(param)

   The expected returns values are
     -2 :  the name has been recognized but won't be usable
     -1 :  the name has not been recognized
    >=0 :  the name has been recognized, return the internal code for this name.

 Return the leaf (if any) of the tree with contains an object of a class
 having a method which has the name provided in the argument.

 Now let calculate what physical instance we really need.
 Some redundant code is used to speed up the cases where
 they are no dimensions.
 We know that instance is less that fCumulUsedSize[0] so
 we can skip the modulo when virt_dim is 0.

  Evaluate the class of this treeformula

  If the 'value' of this formula is a simple pointer to an object,
  this function returns the TClass corresponding to its type.

  Evaluate the class of the operation oper

  If the 'value' in the requested operation is a simple pointer to an object,
  this function returns the TClass corresponding to its type.

Evaluate this treeformula*-*-*-*-
*-*                  =========================

  Return the address of the object pointed to by the formula.
  Return 0 if the formula is not a single object
  The object type can be retrieved using by call EvalClass();

 Eval the instance as a string.

Evaluate this treeformula*-*-*-*-
*-*                  =========================

-*-*Return DataMember corresponding to code
*-*            =======================================

  function called by TLeafObject::GetValue
  with the value of fLookupType computed in TTreeFormula::DefinedVariable

-*-*Return leaf corresponding to serial number n
*-*            ============================================

-*-*Return methodcall corresponding to code
*-*            =======================================

  function called by TLeafObject::GetValue
  with the value of fLookupType computed in TTreeFormula::DefinedVariable

*-*Return number of available instances in the formula
*-*            ===================================================

 Return result of a leafobject method.

 Return result of a leafobject method.

 return TRUE if the formula corresponds to one single Tree leaf
 and this leaf is short, int or unsigned short, int
 When a leaf is of type integer or string, the generated histogram is forced
 to have an integer bin width

 return TRUE if the leaf corresponding to code is short, int or unsigned
 short, int When a leaf is of type integer, the generated histogram is
 forced to have an integer bin width

 return TRUE if the formula is a string

 (fOper[i]>=105000 && fOper[i]<110000) || fOper[i] == kStrings)

 return TRUE if the leaf or data member corresponding to code is a string

 Return value of variable as a string

      mode = -2 : Print line with ***
      mode = -1 : Print column names
      mode = 0  : Print column values

 Return value of variable as a string

      mode = -2 : Print line with ***
      mode = -1 : Print column names
      mode = 0  : Print column values
  decform contains the requested format (with the same convention as printf).

 Tell the formula that we are going to request a new entry.

 Set the axis (in particular get the type).

 Stream an object of class TTreeFormula.

 Try to 'demote' a string into an array bytes.  If this is not possible,
 return false.

 this function is called TTreePlayer::UpdateFormulaLeaves, itself
 called by TChain::LoadTree when a new Tree is loaded.
 Because Trees in a TChain may have a different list of leaves, one
 must update the leaves numbers in the TTreeFormula used by the TreePlayer.

 Populate the TTreeFormulaManager with the dimension information.

 Make sure that all the branches have been loaded properly.

 Convert the fOper of a TTTreeFormula version fromVersion to the current in memory version

 Convert the underlying lookup method from the direct technique
 (dereferencing the address held by the branch) to the method using
 TFormLeafInfo.  This is in particular usefull in the case where we
 need to append an additional TFormLeafInfo (for example to call a
 method).
 Return false if the switch was unsuccessfull (basically in the
 case of an old style split tree).