run_index.h

#pragma once
 
#include "Rtypes.h"
#include <optional>
#include <iostream>
#include "KVString.h"
#include <set>
#include "KVNumberList.h"
 
class run_index_t : public std::pair<int, std::optional<int>> {
public:
   run_index_t(int run, std::optional<int> index)
      : std::pair<int, std::optional<int>>(run, index)
   {
      if (index.has_value() && index.value() == -1)
         second = std::nullopt;
   }
   run_index_t() = default;
   run_index_t(const run_index_t&) = default;
   run_index_t(run_index_t&&) = default;
   run_index_t& operator=(const run_index_t&) = default;
   run_index_t& operator=(run_index_t&&) = default;
   run_index_t(const TString &rs)
   {
      set(rs);
   }
 
   int run() const
   {
      return first;
   }
   int index(int no_index = -1) const
   {
      return second.value_or(no_index);
   }
   bool has_index() const
   {
      return second.has_value();
   }
   void set_run(int r)
   {
      first = r;
   }
   void set_index(int i)
   {
      second = i;
   }
 
   void clear()
   {
      first = 0;
      second = std::nullopt;
   }
   void set(const TString& rs)
   {
      clear();
      KVString n(rs);
      n.Begin(".");
      while (!n.End()) {
         if (!run())
            set_run(n.Next().Atoi());
         else
            set_index(n.Next().Atoi());
      }
   }
   TString as_string() const
   {
      TString s = Form("%d", run());
      if (has_index()) s += "." + TString(Form("%d", index()));
      return s;
   }
   TString index_string() const
   {
      if (has_index()) return Form("%d", index());
      return "-";
   }
   friend std::ostream& operator<<(std::ostream& out, const run_index_t& rndx)
   {
      return out << rndx.as_string();
   }
 
   friend bool operator<(const run_index_t& A, const run_index_t& B)
   {
      if (A.run() < B.run()) return true;
      if (A.run() > B.run()) return false;
      return A.index() < B.index();
   }
   friend bool operator==(const run_index_t& A, const run_index_t& B)
   {
      return (A.run() == B.run()) && (A.index() == B.index());
   }
 
   ClassDef(run_index_t, 0)
};
 
class run_index_list {
   std::set<run_index_t> fRunList;
public:
   run_index_list(const TString& l)
   {
      SetList(l);
   }
   run_index_list() = default;
   run_index_list(const run_index_list&) = default;
   run_index_list(run_index_list&&) = default;
   run_index_list& operator=(const run_index_list&) = default;
   run_index_list& operator=(run_index_list&&) = default;
 
   auto begin() const
   {
      return std::begin(fRunList);
   }
   auto end() const
   {
      return std::end(fRunList);
   }
 
   void Add(const run_index_t& r)
   {
      fRunList.insert(r);
   }
   void Add(const run_index_list&);
   void Remove(const run_index_t& r)
   {
      fRunList.erase(r);
   }
   void Remove(const run_index_list&);
 
   bool Contains(const run_index_t& r) const
   {
      return fRunList.count(r) > 0;
   }
   bool IsEmpty() const
   {
      return fRunList.empty();
   }
   TString GetList(bool no_commas=true) const;
   void SetList(const TString& slist);
   TString AsString(Int_t maxlen = 0) const;
   Int_t GetNValues() const
   {
      return fRunList.size();
   }
   Int_t GetEntries() const
   {
      return GetNValues();
   }
   void Clear()
   {
      fRunList.clear();
   }
   void ls() const
   {
      std::cout << AsString() << std::endl;
   }
   void Inter(const run_index_list&);
   KVNumberList GetRunNumberList() const;
 
   friend run_index_list operator-(const run_index_list& A, const run_index_list& B)
   {
      auto tmp = A;
      tmp.Remove(B);
      return tmp;
   }
 
   friend run_index_list operator+(const run_index_list& A, const run_index_list& B)
   {
      auto tmp = A;
      tmp.Add(B);
      return tmp;
   }
 
   const run_index_t& First() const
   {
      auto it = fRunList.cbegin();
      return *it;
   }
   const run_index_t& Last() const
   {
      auto it = fRunList.crbegin();
      return *it;
   }
 
   ClassDef(run_index_list, 0)
};