BranchConfig.hpp

/* Copyright (C) 2019-2021 GSI, Universität Tübingen
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Viktor Klochkov, Ilya Selyuzhenkov */
 
#ifndef ANALYSISTREE_BRANCHCONFIG_H
#define ANALYSISTREE_BRANCHCONFIG_H
 
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
 
#include <TObject.h>
 
#include "Constants.hpp"
 
namespace AnalysisTree {

struct ConfigElement {
  ConfigElement() = default;
  virtual ~ConfigElement() = default;
 
  explicit ConfigElement(ShortInt_t id, std::string title) : id_(id), title_(std::move(title)) {}
  ShortInt_t id_{0};
  std::string title_;
 
 protected:
  ClassDef(ConfigElement, 1)
};
 
typedef std::map<std::string, ConfigElement> MapType;

template<typename T>
class VectorConfig {
 public:
  VectorConfig() = default;
  VectorConfig(const VectorConfig&) = default;
  explicit VectorConfig(const MapType& map) : map_(map), size_(map.size()) {}
  VectorConfig(VectorConfig&&) noexcept(std::is_nothrow_move_constructible<MapType>::value) = default;
  VectorConfig& operator=(VectorConfig&&) noexcept(std::is_nothrow_move_assignable<MapType>::value) = default;
  VectorConfig& operator=(const VectorConfig&) = default;
  virtual ~VectorConfig() = default;
 
  virtual void AddField(const std::string& name, const std::string& title) {
    map_.insert(std::make_pair(name, ConfigElement(size_++, title)));
  }
  virtual void AddField(const std::string& name, ShortInt_t id, const std::string& title) {
    map_.insert(std::make_pair(name, ConfigElement(id, title)));
  }
  void AddField(const std::string& name, const ConfigElement& field) {
    map_.insert(std::make_pair(name, field));
  }
  virtual void AddFields(const std::vector<std::string>& names, const std::string& title) {
    for (const auto& name : names) {
      map_.insert(std::make_pair(name, ConfigElement(size_++, title)));
    }
  }
 
  ANALYSISTREE_ATTR_NODISCARD ShortInt_t GetId(const std::string& sField) const {
    auto search = map_.find(sField);
    if (search != map_.end()) {
      return search->second.id_;
    } else {
      return UndefValueShort;
    }
  }
 
  ANALYSISTREE_ATTR_NODISCARD virtual const MapType& GetMap() const { return map_; }
  ANALYSISTREE_ATTR_NODISCARD virtual ShortInt_t GetSize() const { return size_; }
 
  virtual void Print() const {
    if (map_.empty()) return;
 
    auto print_row = [](const std::vector<std::pair<std::string, int>>& elements) {
      for (const auto& el : elements) {
        std::cout << std::left << std::setw(el.second) << std::setfill(' ') << el.first;
      }
      std::cout << std::endl;
    };
 
    int name_strlen{0};
    for (const auto& entry : map_) {
      name_strlen = std::max(name_strlen, (int) entry.first.length());
    }
    name_strlen += 4;
 
    print_row({{"Id", 10}, {"Name", name_strlen}, {"Info", 50}});
    for (const auto& entry : map_) {
      if (entry.second.title_.find("\n") == std::string::npos) {
        print_row({{std::to_string(entry.second.id_), 10}, {entry.first, name_strlen}, {entry.second.title_, 50}});
      } else {
        auto est = SplitString(entry.second.title_);
        print_row({{std::to_string(entry.second.id_), 10}, {entry.first, name_strlen}, {est.at(0), 50}});
        for (int iest = 1; iest < est.size(); ++iest) {
          print_row({{"", 10}, {"", name_strlen}, {est.at(iest), 50}});
        }
      }
    }
  }
 
 protected:
  static std::vector<std::string> SplitString(const std::string& input);
  void RemoveField(const std::string& name, int id);
  MapType map_{};
  ShortInt_t size_{0};
  ClassDef(VectorConfig, 2)
};


class BranchConfig : public VectorConfig<int>, public VectorConfig<float>, public VectorConfig<bool> {
 
 public:
  BranchConfig() = default;
  BranchConfig(const BranchConfig&) = default;
  BranchConfig(BranchConfig&&) = default;
  BranchConfig& operator=(BranchConfig&&) = default;
  BranchConfig& operator=(const BranchConfig&) = default;
  ~BranchConfig() override = default;
 
  BranchConfig(std::string name, DetType type, std::string title = "");
 
  void Print() const override;
 
  void PrintBranchId() const;
 
  ANALYSISTREE_ATTR_NODISCARD Types GetFieldType(const std::string& sField) const;
  ANALYSISTREE_ATTR_NODISCARD ShortInt_t GetFieldId(const std::string& sField) const;
 
  // Setters
  template<typename T>
  void AddField(const std::string& name, const std::string& title = "") {
    GuaranteeFieldNameVacancy(name);
    VectorConfig<T>::AddField(name, title);
  }
  template<typename T>
  void AddFields(const std::vector<std::string>& names, const std::string& title = "") {
    for (auto& n : names) {
      GuaranteeFieldNameVacancy(n);
    }
    VectorConfig<T>::AddFields(names, title);
  }
  template<typename T>
  void AddField(const std::string& name, ShortInt_t id, const std::string& title = "") {
    GuaranteeFieldNameVacancy(name);
    VectorConfig<T>::AddField(name, id, title);
  }
 
  void RemoveField(const std::string& name);
 
  void RemoveFields(const std::vector<std::string>& names) {
    for (auto& n : names) {
      RemoveField(n);
    }
  }
 
  void SetTitle(std::string title) { title_ = std::move(title); }
 
  // Getters
  template<typename T>
  ANALYSISTREE_ATTR_NODISCARD const MapType& GetMap() const { return VectorConfig<T>::GetMap(); }
  template<typename T>
  ANALYSISTREE_ATTR_NODISCARD ShortInt_t GetSize() const { return VectorConfig<T>::GetSize(); }
 
  ANALYSISTREE_ATTR_NODISCARD std::string GetName() const { return name_; }
  ANALYSISTREE_ATTR_NODISCARD std::string GetTitle() const { return title_; }
 
  template<typename T>
  ANALYSISTREE_ATTR_NODISCARD std::vector<std::string> GetFieldsNamesT() const {
    std::vector<std::string> result;
    std::transform(begin(GetMap<T>()), end(GetMap<T>()), back_inserter(result),
                   [](const typename MapType::value_type& elem) { return elem.first; });
    return result;
  }
  ANALYSISTREE_ATTR_NODISCARD size_t GetId() const { return id_; }
  ANALYSISTREE_ATTR_NODISCARD DetType GetType() const { return type_; }

  ANALYSISTREE_ATTR_NODISCARD BranchConfig Clone(const std::string& name, DetType type) const;
 
  ANALYSISTREE_ATTR_NODISCARD BranchConfig CloneAndMerge(const BranchConfig& attached) const;
 
  bool HasField(const std::string& field) const { return GetFieldId(field) != UndefValueShort; }
 
 protected:
  void GenerateId();
 
  void GuaranteeFieldNameVacancy(const std::string& name) const;
 
  std::string name_;
  std::string title_;
  size_t id_{0};
  DetType type_{DetType(UndefValueShort)};
 
  ClassDefOverride(BranchConfig, 4);
};
 
// BranchConfig Merge(const BranchConfig& primary, const BranchConfig& secondary);
 
}// namespace AnalysisTree
#endif//ANALYSISTREE_BRANCHCONFIG_H