RootPersistenceService.h

Go to the documentation of this file.

/*
 * RootPersistenceService.h
 *
 *  Created on: 12 May 2017
 *      Author: Nicola Mori
 */

#ifndef ROOTPERSISTENCESERVICE_H_
#define ROOTPERSISTENCESERVICE_H_

#include "persistence/PersistenceService.h"

class TFile;
class TObject;
class TTree;
class TBranch;
class TClass;
class RootOutputStruct;

#include <set>
#include <unordered_map>

namespace EA {

class RootPersistenceService : public PersistenceService {
public:
  RootPersistenceService(const std::string &name, const std::string &output);

  bool Connect() override;
  bool Disconnect() override;

  bool BookEventObject(const std::string &objName, const std::string &objStore) override;
  bool BookPassObject(const std::string &objName, const std::string &objStore) override;
  bool BookGlobalObject(const std::string &objName, const std::string &objStore) override;

  bool BeginOfEvent() override;
  bool EndOfEvent() override;
  bool BeginOfPass() override;
  bool EndOfPass() override;
  bool BeginOfProcessing() override;
  bool EndOfProcessing() override;

  std::unique_ptr<PersistenceService> Copy(const std::string &name, const std::string &output) override;

protected:
  observer_ptr<TFile> GetOutputFile() { return _outputFile; }

  observer_ptr<TTree> GetEventTree() { return _eventTree; }

private:
  /* ******* Bookkeeping structs for output data objects ******* */
  // Event
  struct EvObjInfo {
    std::string dataStoreName;
    StorePtr dataStore;
    TBranch *outputBranch;
    void *object;
    void *defaultObject;
    TClass *objClass;
    void *prevObject; // Address used for previous fill
    bool flag;        // True if the object is present for current event

    EvObjInfo(const std::string &storeName)
        : dataStoreName(storeName), dataStore(nullptr), outputBranch(nullptr), flag(true), object(nullptr),
          defaultObject(nullptr), objClass(nullptr), prevObject(nullptr) {}
  };
  using EvObjectsBook = std::unordered_map<std::string, EvObjInfo>;
  EvObjectsBook _eventBook;

  // Global
  struct GlobObjInfo {
    std::string dataStoreName;
    StorePtr dataStore;
    bool isGlob;              // True if the object name is a glob expression
    bool isAlias;             // True if the object name is an alias
    bool aliasToBeChecked;    // Set to false after checking if the object name is an alias
    TBranch *nameForEvBranch; // Branch storing the name of aliased global object for each event
    std::string nameForThisEv;
    std::set<std::string> actualNames; // Set of all the names assumed by the aliased object
    bool saved;                        // Flag for saved global objects

    GlobObjInfo(const std::string &storeName)
        : dataStoreName(storeName), dataStore(nullptr), isGlob(false), isAlias(false), aliasToBeChecked(true),
          nameForEvBranch(nullptr), saved(false) {}
  };
  using GlobObjectsBook = std::unordered_map<std::string, GlobObjInfo>;
  GlobObjectsBook _globalBook;

  /* ******* Pointers to Root output objects ******* */
  TFile *_outputFile;
  TTree *_eventTree;

  bool _EndOfEventForEventObject(const std::string &objName, EvObjInfo &objInfo);
  bool _EndOfEventForGlobalObject(const std::string &objName, GlobObjInfo &objInfo);
  bool _SaveGlobalObject(const std::string &objName, GlobObjInfo &objInfo);
};

} // namespace EA

#endif /* ROOTPERSISTENCESERVICE_H_ */