ARICHDatabaseTools.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <algorithm>
#include <sstream>
 
#include <array>
#include <cctype>
#include <cstdint>
#include <string>
#include <vector>
 
namespace Belle2 {
  namespace ARICHTools {
 
    class ModuleID_t {
    public:
      // range definitions
      static constexpr auto m_gValidSectors =
      std::array<uint8_t, 4>({{'A', 'B', 'C', 'D'}});
 
      static constexpr auto m_gMaxChannel = int8_t{36};
 
      static constexpr auto isValidChannel(const int channel) noexcept -> bool
      {
        return (channel >= 0) && (channel <= m_gMaxChannel);
      }
 
      static auto isValidSector(const uint8_t sector) noexcept -> bool
      {
        return std::find(m_gValidSectors.begin(), m_gValidSectors.end(), sector) !=
               m_gValidSectors.end();
      }
 
    public:
      ModuleID_t(const int8_t sector = '0', const int channel = 0) noexcept
        : m_ID((sector << m_gMemberSize) | channel) {}
 
      explicit ModuleID_t(const uint16_t id) noexcept : m_ID(id) {}
 
      inline auto isValidID() const noexcept -> bool
      {
        return ModuleID_t::isValidSector(this->getSector()) &&
               ModuleID_t::isValidChannel(this->getChannel());
      }
 
      inline auto getSector() const noexcept -> int8_t
      {
        return ((m_ID >> m_gMemberSize) & m_gMemberMask);
      }
 
      inline auto getChannel() const noexcept -> int8_t
      {
        return (m_ID & m_gMemberMask);
      }
 
      inline auto getNumbering() const noexcept -> int
      {
        return (this->getSector() - m_gValidSectors.front()) * m_gMaxChannel +
               this->getChannel();
      }
 
      friend inline auto operator<<(std::ostream& rStream, const ModuleID_t id)
      -> std::ostream& {
        rStream << id.getSector() << static_cast<int>(id.getChannel());
        return rStream;
      }
 
      inline auto operator==(const ModuleID_t& rOther) const noexcept -> bool
      {
        return m_ID == rOther.m_ID;
      }
 
      inline auto operator!=(const ModuleID_t& rOther) const noexcept -> bool
      {
        return m_ID != rOther.m_ID;
      }
 
      inline auto operator<(const ModuleID_t& rOther) const noexcept -> bool
      {
        return m_ID < rOther.m_ID;
      }
 
      inline auto operator<=(const ModuleID_t& rOther) const noexcept -> bool
      {
        return m_ID <= rOther.m_ID;
      }
 
      inline auto operator>(const ModuleID_t& rOther) const noexcept -> bool
      {
        return m_ID > rOther.m_ID;
      }
 
      inline auto operator>=(const ModuleID_t& rOther) const noexcept -> bool
      {
        return m_ID >= rOther.m_ID;
      }
 
      inline auto operator++() noexcept -> ModuleID_t&
      {
        m_ID = this->getChannel() >= m_gMaxChannel
               ? (((this->getSector() + 1) << m_gMemberSize) | 1)
               : m_ID + 1;
        return *this;
      }
 
      inline auto operator++(int)noexcept -> ModuleID_t
      {
        auto tmp = ModuleID_t(m_ID);
        this->operator++();
        return tmp;
      }
 
    private:
      static constexpr auto m_gMemberSize = sizeof(int8_t) * 8;
      static constexpr auto m_gMemberMask = 0xff;
 
      uint16_t m_ID;
    };
    constexpr std::array<uint8_t, 4> ModuleID_t::m_gValidSectors;
 
    namespace PrivateHelperClasses {
// helper classes for the defined conversions
 
      template <typename Desired_t> struct TokenCast;
 
      template <> struct TokenCast<int> {
        inline auto isValidChar(const unsigned char character) const noexcept
        -> bool
        {
          return std::isdigit(character);
        }
 
        inline auto operator()(const std::string& rToken) const -> int
        {
          return std::stoi(rToken);
        }
      };
 
      template <> struct TokenCast<double> {
        inline auto isValidChar(const unsigned char character) const noexcept
        -> bool
        {
          return std::isdigit(character) || (static_cast<unsigned char>('.') == character);
        }
 
        inline auto operator()(const std::string& rToken) const -> double
        {
          return std::stod(rToken);
        }
      };
 
      template <> struct TokenCast<ModuleID_t> {
        inline auto isValidChar(const unsigned char character) const noexcept
        -> bool
        {
          return std::isdigit(character) || ModuleID_t::isValidSector(character);
        }
 
        inline auto operator()(const std::string& rToken) const -> ModuleID_t
        {
          const auto begin =
            std::find_if(rToken.begin(), rToken.end(),
          [](const char c) { return !std::isspace(c); });
          const auto end = std::find_if(begin, rToken.end(),
          [](const char c) { return std::isspace(c); });
 
          if ((begin + 1 == end) || !std::all_of(begin, end, [this](const char c) {
          return this->isValidChar(c);
          }))
          throw std::invalid_argument("Invalid argiment for module cast, got: '" +
                                      rToken + "'!");
 
          const auto chID = std::stoi(std::string(begin + 1, end));
          if (ModuleID_t::isValidSector(*begin) && ModuleID_t::isValidChannel(chID))
            return ModuleID_t(*begin, chID);
 
          throw std::out_of_range("Module ID out of range. got: '" + rToken + "' !");
        }
      };
    } // end namespace PrivateHelperClasses
 
    class StringToVector {
    public:
      static const std::string m_gRangeOperator;
 
    public:
      template <typename T>
      static inline auto convert(const std::string& rLine, const char delim = ' ')
      -> std::vector<T> {
        const auto cast = PrivateHelperClasses::TokenCast<T>();
        // check if line only contains white space, numbers and delimiter char.
        if (!std::all_of(rLine.begin(), rLine.end(),
        [&cast, delim](const unsigned char c)
      {
        return std::isdigit(c) || std::isspace(c) ||
          (c == delim) || cast.isValidChar(c);
        }))
        throw std::runtime_error("Detected invalid character in '" + rLine +
        "'!");
 
        auto iss = std::istringstream(rLine);
        auto retval = std::vector<T>();
        auto token = std::string();
 
        // convert string to number and add it to vector...
        while (std::getline(iss, token, delim))
          try {
            retval.emplace_back(cast(token));
          } catch (const std::invalid_argument& rErr)
          {
            throw std::runtime_error("Invalid token, got:'" + token + "'! " +
            rErr.what());
          } catch (const std::out_of_range& rErr)
          {
            // if the values exceeds the requested type
            throw std::runtime_error("Conversion out of range, got: '" + token +
            "'! " + rErr.what());
          }
 
        return retval;
      }
 
      template <typename T>
      static inline auto parse(const std::string& rLine, const char delim = ' ')
      -> std::string {
        auto out = std::stringstream();
        auto iss = std::istringstream(rLine);
        auto token = std::string();
 
        if (!std::getline(iss, token, delim))
          return std::string();
 
        if (std::search(token.begin(), token.end(), m_gRangeOperator.begin(),
        m_gRangeOperator.end()) != token.end())
        {
          StringToVector::expand<T>(out, delim, token);
        } else {
          out << token;
        }
 
        // convert string to number and add it to vector...
        while (std::getline(iss, token, delim))
          try {
            if (std::search(token.begin(), token.end(), m_gRangeOperator.begin(),
            m_gRangeOperator.end()) != token.end())
            {
              out << ',';
              StringToVector::expand<T>(out, delim, token);
            } else {
              out << delim << token;
            }
          } catch (const std::invalid_argument& rErr)
          {
            throw std::runtime_error("Invalid token, got:'" + token + "'! " +
            rErr.what());
          } catch (const std::out_of_range& rErr)
          {
            // if the values exceeds the requested type
            throw std::runtime_error("Conversion out of range, got: '" + token +
            "'! " + rErr.what());
          }
        return out.str();
      }
 
    private:
      template <typename T>
      static inline auto expand(std::ostream& rStream, const char delim,
                                const std::string& rToken) -> std::ostream& {
        auto itPos = std::search(rToken.begin(), rToken.end(),
        m_gRangeOperator.begin(), m_gRangeOperator.end());
        const auto cast = PrivateHelperClasses::TokenCast<T>();
        auto lhs = cast(std::string(rToken.begin(), itPos));
        std::advance(itPos, m_gRangeOperator.size());
        auto rhs = cast(std::string(itPos, rToken.end()));
 
        if (lhs >= rhs)
          throw std::runtime_error(
            "Invalid expansion! lhs ist greater then rhs, got: '" + rToken +
            "'!");
 
        rStream << lhs;
        for (++lhs; lhs <= rhs; ++lhs)
          rStream << delim << lhs;
        return rStream;
      }
    };
    const std::string StringToVector::m_gRangeOperator("～");
 
    auto getDeadCutList(const char chipID, const std::string& line)
    -> std::vector<int> {
      auto ids = StringToVector::convert<int>(line, ','); // can throw
      for (auto& rID : ids)
        rID = ModuleID_t(chipID, rID).getNumbering();
 
      return ids;
    }
 
    std::string& remove_nondigit(std::string& s)
    {
      // changed to unsigned char see documention of std::isdigit in <cctype>
      s.erase(remove_if(s.begin(), s.end(),
      [](const unsigned char& c) { return !std::isdigit(c); }),
      s.end());
      return s;
    }
 
    std::string& remove_chars_if_not(std::string& s, const std::string& allowed)
    {
      s.erase(remove_if(s.begin(), s.end(),
      [&allowed](const char& c) {
        return allowed.find(c) == std::string::npos;
      }),
      s.end());
      return s;
    }
 
  } // end namepace ARICHTools
} // end namepace Belle2