RMGAnalysisReader.hh

// Copyright (C) 2024 Manuel Huber <https://orcid.org/0009-0000-5212-2999>
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option) any
// later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef _RMG_ANALYSIS_READER_HH_
#define _RMG_ANALYSIS_READER_HH_
 
#include <map>
#include <string>
 
#include "G4AutoLock.hh"
#include "G4VAnalysisReader.hh"
 
#include "RMGConfig.hh"

class RMGAnalysisReader final {
 
  public:

    class Access final {
        friend class RMGAnalysisReader;
 
      public:
 
        ~Access() { unlock(); }
 
        Access(Access const&) = delete;
        Access& operator=(Access&) = delete;
        Access& operator=(Access const&) = delete;
        Access& operator=(Access&&) = delete;

        void unlock() {
          fReader = nullptr;
          fNtupleId = -1;
          fUnits = nullptr;
          if (fLock) { fLock.unlock(); }
        }

        void Seek(size_t offset) {
          AssertSetup(false);
          for (size_t i = 0; i < offset; i++) fReader->GetNtupleRow(fNtupleId);
        }

        [[nodiscard]] auto GetNtupleRow() {
          AssertSetup(false);
          return fReader->GetNtupleRow(fNtupleId);
        }

        auto SetNtupleDColumn(
            const std::string& name,
            G4double& value,
            const std::vector<std::string>& allowed_units = {}
        ) {
          AssertSetup(true);
          AssertUnit(name, allowed_units);
          return fReader->SetNtupleDColumn(fNtupleId, name, value);
        }

        auto SetNtupleFColumn(
            const std::string& name,
            G4float& value,
            const std::vector<std::string>& allowed_units = {}
        ) {
          AssertSetup(true);
          AssertUnit(name, allowed_units);
          return fReader->SetNtupleFColumn(fNtupleId, name, value);
        }

        auto SetNtupleIColumn(
            const std::string& name,
            G4int& value,
            const std::vector<std::string>& allowed_units = {}
        ) {
          AssertSetup(true);
          AssertUnit(name, allowed_units);
          return fReader->SetNtupleIColumn(fNtupleId, name, value);
        }

        [[nodiscard]] std::string GetUnit(const std::string& name) const;

        operator bool() const { return fReader != nullptr && fNtupleId >= 0 && fLock; }
 
      private:
 
        // only allow creation or moving in parent.
        Access(
            G4AutoLock lock,
            G4VAnalysisReader* reader,
            int nt,
            const std::map<std::string, std::string>* u,
            bool setup
        )
            : fReader(reader), fNtupleId(nt), fUnits(u), fLock(std::move(lock)), fCanSetup(setup) {};
        Access(Access&&) = default;
 
        void AssertUnit(const std::string& name, const std::vector<std::string>& allowed_units) const;
        void AssertSetup(bool setup) const;
 
        G4VAnalysisReader* fReader = nullptr;
        int fNtupleId = -1;
        const std::map<std::string, std::string>* fUnits;
        G4AutoLock fLock;
        bool fCanSetup = false;
    };
 
    RMGAnalysisReader() = default;
    ~RMGAnalysisReader() = default;
 
    RMGAnalysisReader(RMGAnalysisReader const&) = delete;
    RMGAnalysisReader& operator=(RMGAnalysisReader const&) = delete;
    RMGAnalysisReader(RMGAnalysisReader&&) = delete;
    RMGAnalysisReader& operator=(RMGAnalysisReader&&) = delete;

    [[nodiscard]] Access OpenFile(
        const std::string& file_name,
        std::string ntuple_dir_name,
        std::string ntuple_name,
        G4AutoLock lock,
        std::string force_ext = ""
    );
    [[nodiscard]] Access OpenFile(
        const std::string& file_name,
        std::string ntuple_dir_name,
        std::string ntuple_name,
        std::string force_ext = ""
    );

    void CloseFile();

    [[nodiscard]] Access GetLockedReader() const;

    [[nodiscard]] G4AutoLock GetLock() const;

    [[nodiscard]] auto& GetFileName() const { return fFileName; }
 
  private:
 
    static G4Mutex fMutex;
 
    G4VAnalysisReader* fReader = nullptr;
    int fNtupleId = -1;
 
    std::map<std::string, std::string> fUnits;
    bool fHasUnits = false;
 
    std::string fFileName;
    bool fFileIsTemp = false;
};
 
#endif
 
// vim: tabstop=2 shiftwidth=2 expandtab