SampleHandler.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
//
// includes
//
 
//protect
#include <SampleHandler/SampleHandler.h>
 
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <TFile.h>
#include <TSystem.h>
#include <RootCoreUtils/Assert.h>
#include <RootCoreUtils/StringUtil.h>
#include <SampleHandler/DiskListLocal.h>
#include <SampleHandler/MetaFields.h>
#include <SampleHandler/MetaObject.h>
#include <SampleHandler/Sample.h>
 
//
// method implementations
//
 
ClassImp (SH::SampleHandler)
 
namespace SH
{
  namespace
  {
    /*
    bool isspace (const std::string& str)
    {
      for (std::string::const_iterator iter = str.begin(),
         end = str.end(); iter != end; ++ iter)
      {
    if (!std::isspace (*iter))
      return false;
      };
      return true;
    }
    */
  }
 
 
 
  std::string dbg (const SampleHandler& obj, unsigned verbosity)
  {
    std::ostringstream result;
    result << "SampleHandler with " << obj.size() << " files";
    if (verbosity % 10 > 0)
    {
      result << "\n";
      for (SampleHandler::iterator sample = obj.begin(),
         end = obj.end(); sample != end; ++ sample)
      {
    result << dbg (**sample, verbosity / 10) << "\n";
      };
    };
    return result.str();
  }
 
 
 
  void swap (SampleHandler& a, SampleHandler& b)
  {
    swap (a.m_samples, b.m_samples);
    swap (a.m_named, b.m_named);
  }
 
 
 
  void SampleHandler ::
  testInvariant () const
  {
  }
 
 
 
  SampleHandler ::
  SampleHandler ()
  {
    RCU_NEW_INVARIANT (this);
  }
 
 
 
  SampleHandler ::
  SampleHandler (const SampleHandler& that)
    : TObject (that), m_samples (that.m_samples), m_named (that.m_named)
  {
    RCU_NEW_INVARIANT (this);
  }
 
 
 
  SampleHandler ::
  ~SampleHandler ()
  {
    RCU_DESTROY_INVARIANT (this);
  }
 
 
 
  SampleHandler& SampleHandler ::
  operator = (const SampleHandler& that)
  {
    // no invariant used
    SampleHandler tmp (that);
    swap (tmp, *this);
    return *this;
  }
 
 
 
  void SampleHandler ::
  add (const Sample& sample)
  {
    // no invariant used
    std::unique_ptr<Sample> copy (dynamic_cast<Sample*> (sample.Clone()));
    RCU_ASSERT (copy != nullptr);
    add (std::move (copy));
  }
 
 
 
  void SampleHandler ::
  add (std::shared_ptr<Sample> sample)
  {
    RCU_CHANGE_INVARIANT (this);
    RCU_REQUIRE_SOFT (sample != nullptr);
    RCU_REQUIRE_SOFT (!sample->name().empty());
 
    if (!sample->name().empty() && m_named.find (sample->name()) != m_named.end())
      throw std::runtime_error ("can't add sample of name " + sample->name() + "\na sample with that name already exists\nold sample:\n" + dbg (*m_named.find (sample->name())->second, 9999) + "\nnew sample:\n" + dbg (*sample, 9999));
 
    try
    {
      m_samples.push_back (sample);
      if (!sample->name().empty())
      {
        sample->lockName ();
        m_named[sample->name()] = std::move (sample);
        sample.reset();
      }
    } catch (...)
    {
      if (!m_samples.empty() && m_samples.back().get() == sample.get())
        m_samples.pop_back();
      throw;
    }
  }
 
 
 
  void SampleHandler ::
  add (const SampleHandler& sh)
  {
    // invariant not used
    RCU_REQUIRE_SOFT (this != &sh);
 
    for (auto& sample : sh.m_samples)
    {
      add (sample);
    };
  }
 
 
 
  void SampleHandler ::
  addWithPrefix (const SampleHandler& sh, const std::string& prefix)
  {
    // invariant not used
    RCU_REQUIRE_SOFT (this != &sh);
 
    for (iterator iter = sh.begin(), end2 = sh.end();
     iter != end2; ++ iter)
    {
      std::unique_ptr<Sample> sample (dynamic_cast<Sample*>((*iter)->Clone ()));
      RCU_ASSERT (sample != nullptr);
      sample->name (prefix + (*iter)->name());
      add (std::move (sample));
    };
  }
 
 
 
  void SampleHandler ::
  remove (const std::string& name)
  {
    // invariant not used
    const Sample *sample = get (name);
    if (sample == 0)
      throw std::runtime_error ("sample " + name + " not found in SampleHandler");
    remove (sample);
  }
 
 
 
  void SampleHandler ::
  remove (const Sample *sample)
  {
    RCU_CHANGE_INVARIANT (this);
    RCU_REQUIRE_SOFT (sample != 0);
 
    auto nameIter = m_named.find (sample->name());
    if (nameIter == m_named.end())
      throw std::runtime_error ("sample " + sample->name() + " not found in SampleHandler");
    if (nameIter->second.get() != sample)
      throw std::runtime_error ("different sample of name " + sample->name() + " found in SampleHandler");
    std::erase_if (m_samples, [sample] (const std::shared_ptr<Sample>& p) { return p.get() == sample; });
    m_named.erase (nameIter);
  }
 
 
 
  Sample *SampleHandler ::
  get (const std::string& name)
  {
    RCU_READ_INVARIANT (this);
 
    auto iter = m_named.find (name);
    if (iter != m_named.end())
      return iter->second.get();
    return 0;
  }
 
 
  const Sample *SampleHandler ::
  get (const std::string& name) const
  {
    RCU_READ_INVARIANT (this);
 
    auto iter = m_named.find (name);
    if (iter != m_named.end())
      return iter->second.get();
    return 0;
  }
 
 
 
  SampleHandler SampleHandler ::
  find (const std::string& tags) const
  {
    // no invariant used
    return find (TagList (tags, ','));
  }
 
 
 
  SampleHandler SampleHandler ::
  find (const TagList& tags) const
  {
    RCU_READ_INVARIANT (this);
 
    SampleHandler result;
 
    for (auto& sample : m_samples)
    {
      bool use = false;
      for (auto iter = tags.begin(),
          end = tags.end(); !use && iter != end; ++ iter)
        use = sample->tags().has (*iter);
      if (use)
        result.add (sample);
    };
    return result;
  }
 
 
 
  Sample *SampleHandler ::
  findBySource (const std::string& name) const
  {
    RCU_READ_INVARIANT (this);
 
    std::vector<Sample*> result;
    for (iterator sample = begin(),
       end2 = end(); sample != end2; ++ sample)
    {
      if (name == (*sample)->meta()->castString (MetaFields::sourceSample, (*sample)->name()))
    result.push_back ((*sample));
    };
    if (result.size() > 1)
    {
      std::ostringstream message;
      message << "multiple samples have " << name << " as a source:";
      for (std::vector<Sample*>::const_iterator sample = result.begin(),
         end = result.end(); sample != end; ++ sample)
    message << " " << (*sample)->name();
      throw std::runtime_error (message.str());
    };
    if (result.empty())
      return 0;
    return result.front();
  }
 
 
 
  SampleHandler SampleHandler ::
  findByName (const std::string& pattern) const
  {
    RCU_READ_INVARIANT (this);
    SampleHandler result;
    std::regex expr (pattern);
    for (auto& sample : m_samples)
    {
      if (RCU::match_expr (expr, sample->name()))
        result.add (sample);
    }
    return result;
  }
 
 
 
  void SampleHandler ::
  print () const
  {
    RCU_READ_INVARIANT (this);
    std::cout << dbg (*this, 9999) << std::endl;
  }
 
 
 
  void SampleHandler ::
  printContent () const
  {
    // not using invariant
    print ();
  }
 
 
 
  void SampleHandler ::
  save (const std::string& directory) const
  {
    RCU_READ_INVARIANT (this);
 
    // rationale: not checking the return status, since this is just a
    //   courtesy directory creation that is Ok to fail.
    gSystem->MakeDirectory (directory.c_str());
    for (iterator iter = this->begin(),
       end = this->end(); iter != end; ++ iter)
    {
      TFile file ((directory + "/" + (*iter)->name() + ".root").c_str(), "RECREATE");
      (*iter)->Write ("sample");
    };
  }
 
 
 
  void SampleHandler ::
  load (const std::string& directory)
  {
    RCU_CHANGE_INVARIANT (this);
 
    DiskListLocal mydir (directory);
    while (mydir.next())
    {
      const std::string file = mydir.fileName();
 
      if (file.size() > 5 &&
      file.rfind (".root") == file.size() - 5)
      {
    TFile myfile (mydir.path().c_str(), "READ");
    std::unique_ptr<Sample> sample {dynamic_cast<Sample*>(myfile.Get ("sample"))};
    if (sample != 0)
      add (std::move(sample));
      };
    };    
  }
 
 
 
  void SampleHandler ::
  updateLocation (const std::string& from, const std::string& to)
  {
    // no invariant used
    RCU_REQUIRE_SOFT (!from.empty());
    RCU_REQUIRE_SOFT (!to.empty());
    for (iterator sample = begin(),
       end = this->end(); sample != end; ++ sample)
      (*sample)->updateLocation (from, to);
  }
 
 
 
  void SampleHandler ::
  fetch (const SampleHandler& source)
  {
    // invariant not used
 
    for (iterator sample = begin(),
       end2 = end(); sample != end2; ++ sample)
    {
      const std::string name
    = (*sample)->meta()->castString (MetaFields::sourceSample, (*sample)->name());
      const Sample *const mysource = source.get (name);
      if (mysource)
    (*sample)->meta()->fetch (*mysource->meta());
    };
  }
 
 
 
  void SampleHandler ::
  fetchDefaults (const SampleHandler& source)
  {
    // invariant not used
 
    for (iterator sample = begin(),
       end2 = end(); sample != end2; ++ sample)
    {
      const std::string name
    = (*sample)->meta()->castString (MetaFields::sourceSample, (*sample)->name());
      const Sample *const mysource = source.get (name);
      if (mysource)
    (*sample)->meta()->fetchDefaults (*mysource->meta());
    };
  }
 
 
 
  bool SampleHandler ::
  check_complete (const SampleHandler& source) const
  {
    // invariant not used
 
    std::set<std::string> names;
    for (iterator sample = begin(),
       end2 = end(); sample != end2; ++ sample)
    {
      names.insert ((*sample)->meta()->castString (MetaFields::sourceSample, (*sample)->name()));
    };
 
    for (iterator sample = source.begin(),
       end2 = source.end(); sample != end2; ++ sample)
    {
      if (names.find ((*sample)->name()) == names.end())
    return false;
    };
    return true;
  }
 
 
 
  void SampleHandler ::
  setMetaDouble (const std::string& name, double value)
  {
    // no invariant used
 
    for (iterator sample = begin(),
       end2 = end(); sample != end2; ++ sample)
    {
      (*sample)->meta()->setDouble (name, value);
    };
  }
 
 
 
  void SampleHandler ::
  setMetaString (const std::string& name, const std::string& value)
  {
    // no invariant used
 
    for (iterator sample = begin(),
       end2 = end(); sample != end2; ++ sample)
    {
      (*sample)->meta()->setString (name, value);
    };
  }
 
 
 
  void SampleHandler ::
  setMetaDouble (const std::string& pattern, const std::string& name,
         double value)
  {
    // no invariant used
 
    std::regex mypattern (pattern);
 
    for (iterator sample = begin(),
       end2 = end(); sample != end2; ++ sample)
    {
      if (RCU::match_expr (mypattern, (*sample)->name()))
    (*sample)->meta()->setDouble (name, value);
    };
  }
 
 
 
  void SampleHandler ::
  setMetaString (const std::string& pattern, const std::string& name,
         const std::string& value)
  {
    // no invariant used
 
    std::regex mypattern (pattern);
 
    for (iterator sample = begin(),
       end2 = end(); sample != end2; ++ sample)
    {
      if (RCU::match_expr (mypattern, (*sample)->name()))
    (*sample)->meta()->setString (name, value);
    };
  }
 
 
 
  Sample *SampleHandler::SamplePtrToRawSample ::
  operator () (const std::shared_ptr<Sample>& p) const
  {
    return p.get();
  }
 
 
 
  SampleHandler::iterator SampleHandler ::
  begin () const
  {
    RCU_READ_INVARIANT (this);
    return boost::make_transform_iterator
      (m_samples.begin(), SamplePtrToRawSample{});
  }
 
 
 
  SampleHandler::iterator SampleHandler ::
  end () const
  {
    RCU_READ_INVARIANT (this);
    return boost::make_transform_iterator
      (m_samples.end(), SamplePtrToRawSample{});
  }
 
 
 
  std::size_t SampleHandler ::
  size () const
  {
    RCU_READ_INVARIANT (this);
    return m_samples.size();
  }
 
 
 
  Sample *SampleHandler ::
  operator [] (std::size_t index) const
  {
    // no invariant used
    return at (index);
  }
 
 
 
  Sample *SampleHandler ::
  at (std::size_t index) const
  {
    RCU_READ_INVARIANT (this);
    RCU_REQUIRE_SOFT (index < size());
    return m_samples[index].get();
  }
 
 
 
  std::span<std::shared_ptr<Sample>> SampleHandler ::
  samples ()
  {
    RCU_READ_INVARIANT (this);
    return std::span<std::shared_ptr<Sample>> (m_samples.data(), m_samples.size());
  }
 
 
 
  void SampleHandler ::
  Streamer (TBuffer& b)
  {
    if (b.IsReading())
    {
      RCU_CHANGE_INVARIANT (this);
      SampleHandler sh;
      ULong_t count = 0;
      b.ReadULong (count);
      for (ULong_t iter = 0; iter != count; ++ iter)
      {
    Sample *sample = 0;
    b >> sample;
    sh.add (std::shared_ptr<Sample>(sample));
      }
      swap (*this, sh);
    } else
    {
      RCU_READ_INVARIANT (this);
      ULong_t count = m_samples.size();
      b.WriteULong (count);
      for (auto iter = m_samples.begin(),
         end = m_samples.end(); iter != end; ++ iter)
      {
    Sample *sample = iter->get();
    b << sample;
      }
    };
  }
}