Bus.h

#ifndef FRAMEWORK_BUS_H
#define FRAMEWORK_BUS_H
 
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
// ROOT
#include "TBranchElement.h"
#include "TTree.h"
 
namespace framework {
 
class Bus {
 public:
  template <typename BaggageType>
  const BaggageType& get(const std::string& name) {
    return getRef<BaggageType>(name).get();
  }
 
  template <typename BaggageType>
  void board(const std::string& name) {
    passengers_[name] = std::make_unique<Passenger<BaggageType>>();
    passengers_[name]->clear();  // make sure 'default' state is well defined
  }
 
  template <typename BaggageType>
  void update(const std::string& name, const BaggageType& obj) {
    getRef<BaggageType>(name).update(obj);
  }
 
  TBranch* attach(TTree* tree, const std::string& name, bool can_create) {
    return passengers_[name]->attach(tree, name, can_create);
  }
 
  bool isOnBoard(const std::string& name) {
    return passengers_.find(name) != passengers_.end();
  }
 
  void clear() {
    for (auto& [n, handle] : passengers_) handle->clear();
  }
 
  void everybodyOff() { passengers_.clear(); }
 
  void stream(std::ostream& s) const {
    for (auto& [n, handle] : passengers_)
      s << n << " : " << handle << std::endl;
  }
 
  friend std::ostream& operator<<(std::ostream& s, const framework::Bus& b) {
    b.stream(s);
    return s;
  }
 
 private:
  class Seat {
   public:
    virtual ~Seat() {}
 
    virtual TBranch* attach(TTree* tree, const std::string& branch_name,
                            bool can_create) = 0;
 
    virtual void clear() = 0;
 
    virtual void stream(std::ostream& s) const = 0;
 
    friend std::ostream& operator<<(
        std::ostream& s, const std::unique_ptr<framework::Bus::Seat>& seat) {
      seat->stream(s);
      return s;
    }
 
  };  // Seat
 
 private:
  template <typename BaggageType>
  class Passenger : public Seat {
   public:
    Passenger() : Seat(), baggage_{new BaggageType} {}
 
    virtual ~Passenger() { delete baggage_; }
 
    virtual TBranch* attach(TTree* tree, const std::string& branch_name,
                            bool can_create) {
      return attach(the_type<BaggageType>{}, tree, branch_name, can_create);
    }
 
    const BaggageType& get() const { return *baggage_; }
 
    void update(const BaggageType& updated_obj) {
      *baggage_ = updated_obj;
      post_update(the_type<BaggageType>());
    }
 
    virtual void clear() { clear(the_type<BaggageType>{}); }
 
    virtual void stream(std::ostream& s) const {
      stream(the_type<BaggageType>{}, s);
    }
 
    friend std::ostream& operator<<(
        std::ostream& s, const framework::Bus::Passenger<BaggageType>& p) {
      p.stream(s);
      return s;
    }
 
   private:
    template <typename>
    struct the_type {};
 
   private:  // specializations of attach
    class DeleteObjectStatus : public TBranchElement {
      DeleteObjectStatus() = delete;
      DeleteObjectStatus(const DeleteObjectStatus&) = delete;
 
     public:
      static int bit() { return TBranchElement::EStatusBits::kDeleteObject; }
    };
 
    template <typename T>
    TBranch* attach(the_type<T> t, TTree* tree, const std::string& branch_name,
                    bool can_create) {
      TBranch* branch = tree->GetBranch(branch_name.c_str());
      if (branch) {
        if (dynamic_cast<TBranchElement*>(branch)) {
          branch->SetBit(DeleteObjectStatus::bit(), false);
        }
        branch->SetObject(baggage_);
      } else if (can_create) {
        branch = tree->Branch(branch_name.c_str(), baggage_, 100000, 3);
      }
      return branch;
    }
 
    TBranch* attachBasic(TTree* tree, const std::string& branch_name,
                         bool can_create) {
      TBranch* branch = tree->GetBranch(branch_name.c_str());
      if (branch) {
        // branch already exists
        //  set the object the branch should read/write from/to
        branch->SetAddress(baggage_);
      } else if (can_create) {
        static const std::map<std::string, std::string> cpp_to_root_type_name =
            {{"b", "O"}, {"s", "S"}, {"i", "I"},
             {"l", "L"}, {"f", "F"}, {"d", "D"}};
        // branch doesnt exist and we are allowed to make a new one
        std::string cpp_type = typeid(*baggage_).name();
        branch = tree->Branch(
            branch_name.c_str(), baggage_,
            (branch_name + "/" + cpp_to_root_type_name.at(cpp_type)).c_str());
      }
      return branch;
    }
 
    TBranch* attach(the_type<bool> t, TTree* tree,
                    const std::string& branch_name, bool can_create) {
      return attachBasic(tree, branch_name, can_create);
    }
 
    TBranch* attach(the_type<short> t, TTree* tree,
                    const std::string& branch_name, bool can_create) {
      return attachBasic(tree, branch_name, can_create);
    }
 
    TBranch* attach(the_type<int> t, TTree* tree,
                    const std::string& branch_name, bool can_create) {
      return attachBasic(tree, branch_name, can_create);
    }
 
    TBranch* attach(the_type<long> t, TTree* tree,
                    const std::string& branch_name, bool can_create) {
      return attachBasic(tree, branch_name, can_create);
    }
 
    TBranch* attach(the_type<float> t, TTree* tree,
                    const std::string& branch_name, bool can_create) {
      return attachBasic(tree, branch_name, can_create);
    }
 
    TBranch* attach(the_type<double> t, TTree* tree,
                    const std::string& branch_name, bool can_create) {
      return attachBasic(tree, branch_name, can_create);
    }
 
   private:  // specializations of clear
    void clear(the_type<bool> t) { *baggage_ = false; }
 
    void clear(the_type<short> t) {
      *baggage_ = std::numeric_limits<BaggageType>::min();
    }
 
    void clear(the_type<int> t) {
      *baggage_ = std::numeric_limits<BaggageType>::min();
    }
 
    void clear(the_type<long> t) {
      *baggage_ = std::numeric_limits<BaggageType>::min();
    }
 
    void clear(the_type<float> t) {
      *baggage_ = std::numeric_limits<BaggageType>::min();
    }
 
    void clear(the_type<double> t) {
      *baggage_ = std::numeric_limits<BaggageType>::min();
    }
 
    template <typename T>
    void clear(the_type<T> t) {
      baggage_->Clear();
    }
 
    template <typename Content>
    void clear(the_type<std::vector<Content>> t) {
      baggage_->clear();
    }
 
    template <typename Key, typename Val>
    void clear(the_type<std::map<Key, Val>> t) {
      baggage_->clear();
    }
 
   private:  // specializations of post_update
    template <typename T>
    void post_update(the_type<T> t) {}
 
   private:  // specializations of stream
    template <typename T>
    void stream(the_type<T> t, std::ostream& s) const {
      // s << *baggagage_;
    }
 
    template <typename Content>
    void stream(the_type<std::vector<Content>> t, std::ostream& s) const {
      s << baggage_->size();
      /*
      s << "[ ";
      for (auto const& entry : *baggage_) s << entry << " ";
      s << "]";
      */
    }
 
    template <typename Key, typename Val>
    void stream(the_type<std::map<Key, Val>> t, std::ostream& s) const {
      s << baggage_->size();
      /*
      s << "{ ";
      for (auto const& [k, v] : *baggage_) {
        s << k << " -> " << v << " ";
      }
      s << "}";
      */
    }
 
   private:
    BaggageType* baggage_;
  };  // Passenger
 
 private:
  template <typename BaggageType>
  Passenger<BaggageType>& getRef(const std::string& name) {
    return dynamic_cast<Passenger<BaggageType>&>(*passengers_[name]);
  }
 
 private:
  std::unordered_map<std::string, std::unique_ptr<Seat>> passengers_;
 
};  // Bus
 
}  // namespace framework
 
#endif  // FRAMEWORK_BUS_H