TConvertingBranchElement.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TCONVERTINGBRANCHELEMENT_H
#define TCONVERTINGBRANCHELEMENT_H
 
#if defined(__clang__)
# pragma clang diagnostic push
# if __has_warning("-Wformat-pedantic")
#  pragma clang diagnostic ignored "-Wformat-pedantic"
# endif
#endif
#include "TBranchElement.h"
#if defined(__clang__)
# pragma clang diagnostic pop
#endif
 
#include <atomic>
 
class TVirtualConverter;
 
class TConvertingBranchElement
#ifndef __REFLEX__
#ifndef __CLING__
  : public TBranchElement
  // Need to hide the base class from reflex and cling so that it doesn't
  // insist on generating the ClassDef functions.
#endif
#endif
{
public:
  // --- Public methods ---
  TConvertingBranchElement();
 
  virtual ~TConvertingBranchElement();
 
  static void Initialize();
 
  virtual Int_t GetEntry(Long64_t entry, Int_t getall);
 
  // Need to hide this from cling; otherwise, genreflex will try to
  // generate an implementation for this.
#ifndef __CLING__
 
  virtual void Streamer(TBuffer& R__b);
#endif
 
  virtual void SetAddress(void* add);
 
  virtual void ResetAddress();
 
 
  static void SetDoDel (bool flag);
 
 
 
protected:
  virtual void InitInfo();
 
  virtual void InitializeOffsets();
 
  void ReadLeavesCollectionConverting(TBuffer& b);
 
  void ReadLeavesMemberBranchCountConverting (TBuffer& b);
 
 
private:
  enum {
    kIsDummy      = BIT(20)
  };
 
  static void* new_TConvertingBranchElement (void* p);
 
  void BuildConvertedElisions();
 
  void CheckForConversion();
 
  void ConvResetType();
 
  Int_t ReadSubBranches(Long64_t entry,
                        Int_t getall,
                        bool dont_reset);
 
  TVirtualConverter *fConv;       
  TClass            *fConvClass;  
  char              *fConvObject; 
  TObjArray         *fConvOrigBranches; 
                                        //  the branch list, we store the
                                        //  original one here, so that
                                        //  when we stream, we use the
                                        //  original.
  Int_t              fConvOrigType;     
                                        //  type is stored here, so that if
                                        //  we stream, we can save the original
                                        //  type.  This is set to -1 before
                                        //  it's initialized.
  bool               fConvContainerFlag; 
                                         //  conversion.
  bool               fConvDontReset;     
                                         //  not reset the buffer pointer.
                                         //  See GetEntry().
  static std::atomic<bool> fgDoDel;      
                                         //  branch object when the branch
                                         //  is deleted.
 
 
  TConvertingBranchElement& operator= (const TConvertingBranchElement&);
  TConvertingBranchElement (const TConvertingBranchElement&);
};
 
#endif