datasize.h

Go to the documentation of this file.

#ifndef LARDATAALG_UTILITIES_QUANTITIES_DATASIZE_H
#define LARDATAALG_UTILITIES_QUANTITIES_DATASIZE_H

// LArSoft libraries
#include "lardataalg/Utilities/quantities.h"

// C/C++ standard libraries
#include <ratio>
#include <string_view>

//------------------------------------------------------------------------------
namespace util::quantities {

  namespace units {

    using namespace std::string_view_literals; // for operator""sv()

    struct Byte : public concepts::UnitBase {
      static constexpr auto symbol = "B"sv;
      static constexpr auto name = "byte"sv;
    };

  } // namespace units

  namespace prefixes {

    using kibi = std::ratio<(1LL << 10)>;

    using mebi = std::ratio<(1LL << 20)>;

    using gibi = std::ratio<(1LL << 30)>;

    using tebi = std::ratio<(1LL << 40)>;

    using pebi = std::ratio<(1LL << 50)>;

    using exbi = std::ratio<(1LL << 60)>;

  } // namespace prefixes

  // -- BEGIN Data size --------------------------------------------------------

  template <typename R, typename T = unsigned long long int>
  using scaled_byte = concepts::scaled_quantity<units::Byte, R, T>;

  //
  // byte
  //
  template <typename T = unsigned long long int>
  using byte_as = scaled_byte<std::ratio<1>, T>;

  template <typename T = unsigned long long int>
  using bytes_as = byte_as<T>;

  using byte = byte_as<>;

  using bytes = byte;

  //
  // kibibyte
  //
  template <typename T = unsigned long long int>
  using kibibyte_as = concepts::rescale<byte_as<T>, prefixes::kibi>;

  template <typename T = unsigned long long int>
  using kibibytes_as = kibibyte_as<T>;

  using kibibyte = kibibyte_as<>;

  using kibibytes = kibibyte;

  //
  // mebibyte
  //
  template <typename T = unsigned long long int>
  using mebibyte_as = concepts::rescale<byte_as<T>, prefixes::mebi>;

  template <typename T = unsigned long long int>
  using mebibytes_as = mebibyte_as<T>;

  using mebibyte = mebibyte_as<>;

  using mebibytes = mebibyte;

  //
  // gibibyte
  //
  template <typename T = unsigned long long int>
  using gibibyte_as = concepts::rescale<byte_as<T>, prefixes::gibi>;

  template <typename T = unsigned long long int>
  using gibibytes_as = gibibyte_as<T>;

  using gibibyte = gibibyte_as<>;

  using gibibytes = gibibyte;

  //
  // tebibyte
  //
  template <typename T = unsigned long long int>
  using tebibyte_as = concepts::rescale<byte_as<T>, prefixes::tebi>;

  template <typename T = unsigned long long int>
  using tebibytes_as = tebibyte_as<T>;

  using tebibyte = tebibyte_as<>;

  using tebibytes = tebibyte;

  //
  // pebibyte
  //
  template <typename T = unsigned long long int>
  using pebibyte_as = concepts::rescale<byte_as<T>, prefixes::pebi>;

  template <typename T = unsigned long long int>
  using pebibytes_as = pebibyte_as<T>;

  using pebibyte = pebibyte_as<>;

  using pebibytes = pebibyte;

  //
  // exbibyte
  //
  template <typename T = unsigned long long int>
  using exbibyte_as = concepts::rescale<byte_as<T>, prefixes::exbi>;

  template <typename T = unsigned long long int>
  using exbibytes_as = exbibyte_as<T>;

  using exbibyte = exbibyte_as<>;

  using exbibytes = exbibyte;

  namespace datasize_literals {

    // @{
    constexpr byte operator""_B(long double v)
    {
      return byte{static_cast<unsigned long long int>(v)};
    }
    constexpr byte operator""_B(unsigned long long int v)
    {
      return byte{v};
    }
    // @}

    // @{
    constexpr kibibyte operator""_kiB(long double v)
    {
      return kibibyte{static_cast<unsigned long long int>(v)};
    }
    constexpr kibibyte operator""_kiB(unsigned long long int v)
    {
      return kibibyte{v};
    }
    // @}

    // @{
    constexpr mebibyte operator""_MiB(long double v)
    {
      return mebibyte{static_cast<unsigned long long int>(v)};
    }
    constexpr mebibyte operator""_MiB(unsigned long long int v)
    {
      return mebibyte{v};
    }
    // @}

    // @{
    constexpr gibibyte operator""_GiB(long double v)
    {
      return gibibyte{static_cast<unsigned long long int>(v)};
    }
    constexpr gibibyte operator""_GiB(unsigned long long int v)
    {
      return gibibyte{v};
    }
    // @}

    // @{
    constexpr tebibyte operator""_TiB(long double v)
    {
      return tebibyte{static_cast<unsigned long long int>(v)};
    }
    constexpr tebibyte operator""_TiB(unsigned long long int v)
    {
      return tebibyte{v};
    }
    // @}

    // @{
    constexpr pebibyte operator""_PiB(long double v)
    {
      return pebibyte{static_cast<unsigned long long int>(v)};
    }
    constexpr pebibyte operator""_PiB(unsigned long long int v)
    {
      return pebibyte{v};
    }
    // @}

    // @{
    constexpr exbibyte operator""_EiB(long double v)
    {
      return exbibyte{static_cast<unsigned long long int>(v)};
    }
    constexpr exbibyte operator""_EiB(unsigned long long int v)
    {
      return exbibyte{v};
    }
    // @}

  } // datasize_literals

  // -- END Data size ----------------------------------------------------------

} // namespace util::quantities

//------------------------------------------------------------------------------
//--- Template specializations
//------------------------------------------------------------------------------
namespace util::quantities::concepts {

  template <>
  struct Prefix<prefixes::kibi> {

    static constexpr auto symbol() { return "ki"sv; }

    static constexpr auto name() { return "kibi"sv; }

  }; // struct Prefix<prefixes::kibi>

  template <>
  struct Prefix<prefixes::mebi> {

    static constexpr auto symbol() { return "Mi"sv; }

    static constexpr auto name() { return "mebi"sv; }

  }; // struct Prefix<prefixes::mebi>

  template <>
  struct Prefix<prefixes::gibi> {

    static constexpr auto symbol() { return "Gi"sv; }

    static constexpr auto name() { return "gibi"sv; }

  }; // struct Prefix<prefixes::gibi>

  template <>
  struct Prefix<prefixes::tebi> {

    static constexpr auto symbol() { return "Ti"sv; }

    static constexpr auto name() { return "tebi"sv; }

  }; // struct Prefix<prefixes::tebi>

  template <>
  struct Prefix<prefixes::pebi> {

    static constexpr auto symbol() { return "Pi"sv; }

    static constexpr auto name() { return "pebi"sv; }

  }; // struct Prefix<prefixes::pebi>

  template <>
  struct Prefix<prefixes::exbi> {

    static constexpr auto symbol() { return "Ei"sv; }

    static constexpr auto name() { return "exbi"sv; }

  }; // struct Prefix<prefixes::exbi>

} // namespace util::quantities::concepts

//------------------------------------------------------------------------------

#endif // LARDATAALG_UTILITIES_QUANTITIES_DATASIZE_H