ratio.h

Go to the documentation of this file.

/*
 * LibrePCB - Professional EDA for everyone!
 * Copyright (C) 2013 LibrePCB Developers, see AUTHORS.md for contributors.
 * https://librepcb.org/
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef LIBREPCB_CORE_RATIO_H
#define LIBREPCB_CORE_RATIO_H

/*******************************************************************************
 *  Includes
 ******************************************************************************/
#include "../exceptions.h"
#include "../qtcompat.h"

#include <type_safe/constrained_type.hpp>

#include <QtCore>

/*******************************************************************************
 *  Namespace / Forward Declarations
 ******************************************************************************/
namespace librepcb {

/*******************************************************************************
 *  Class Ratio
 ******************************************************************************/

class Ratio {
  Q_DECLARE_TR_FUNCTIONS(Ratio)

public:
  // Constructors / Destructor

  constexpr Ratio() noexcept : Ratio(0) {}

  constexpr Ratio(const Ratio& ratio) noexcept : mPpm(ratio.mPpm) {}

  constexpr explicit Ratio(qint32 ppm) noexcept : mPpm(ppm) {}

  ~Ratio() = default;

  // Setters

  void setRatioPpm(qint32 ppm) noexcept { mPpm = ppm; }

  void setRatioPercent(int percent) noexcept { mPpm = percent * 1e4; }

  void setRatioPercent(qreal percent) noexcept { mPpm = percent * 1e4; }

  void setRatioNormalized(qreal normalized) noexcept {
    mPpm = normalized * 1e6;
  }

  void setRatioNormalized(const QString& normalized) {
    mPpm = normalizedStringToPpm(normalized);
  }

  // Conversions

  qint32 toPpm() const noexcept { return mPpm; }

  qreal toPercent() const noexcept { return (qreal)mPpm / 1e4; }

  qreal toNormalized() const noexcept { return (qreal)mPpm / 1e6; }

  QString toNormalizedString() const noexcept;

  // Static Methods

  static Ratio fromPercent(int percent) noexcept;

  static Ratio fromPercent(qreal percent) noexcept;

  static Ratio fromNormalized(qreal normalized) noexcept;

  static Ratio fromNormalized(const QString& normalized);

  // Operators
  Ratio& operator=(const Ratio& rhs) {
    mPpm = rhs.mPpm;
    return *this;
  }
  Ratio& operator+=(const Ratio& rhs) {
    mPpm += rhs.mPpm;
    return *this;
  }
  Ratio& operator-=(const Ratio& rhs) {
    mPpm -= rhs.mPpm;
    return *this;
  }
  Ratio& operator*=(const Ratio& rhs) {
    mPpm *= rhs.mPpm;
    return *this;
  }
  Ratio& operator*=(qint32 rhs) {
    mPpm *= rhs;
    return *this;
  }
  Ratio& operator/=(const Ratio& rhs) {
    mPpm /= rhs.mPpm;
    return *this;
  }
  Ratio& operator/=(qint32 rhs) {
    mPpm /= rhs;
    return *this;
  }
  Ratio operator+(const Ratio& rhs) const { return Ratio(mPpm + rhs.mPpm); }
  Ratio operator-() const { return Ratio(-mPpm); }
  Ratio operator-(const Ratio& rhs) const { return Ratio(mPpm - rhs.mPpm); }
  Ratio operator*(const Ratio& rhs) const { return Ratio(mPpm * rhs.mPpm); }
  Ratio operator*(qint32 rhs) const { return Ratio(mPpm * rhs); }
  Ratio operator/(const Ratio& rhs) const { return Ratio(mPpm / rhs.mPpm); }
  Ratio operator/(qint32 rhs) const { return Ratio(mPpm / rhs); }
  Ratio operator%(const Ratio& rhs) const { return Ratio(mPpm % rhs.mPpm); }
  constexpr bool operator>(const Ratio& rhs) const { return mPpm > rhs.mPpm; }
  constexpr bool operator>(qint32 rhs) const { return mPpm > rhs; }
  constexpr bool operator<(const Ratio& rhs) const { return mPpm < rhs.mPpm; }
  constexpr bool operator<(qint32 rhs) const { return mPpm < rhs; }
  constexpr bool operator>=(const Ratio& rhs) const { return mPpm >= rhs.mPpm; }
  constexpr bool operator>=(qint32 rhs) const { return mPpm >= rhs; }
  constexpr bool operator<=(const Ratio& rhs) const { return mPpm <= rhs.mPpm; }
  constexpr bool operator<=(qint32 rhs) const { return mPpm <= rhs; }
  constexpr bool operator==(const Ratio& rhs) const { return mPpm == rhs.mPpm; }
  constexpr bool operator==(qint32 rhs) const { return mPpm == rhs; }
  constexpr bool operator!=(const Ratio& rhs) const { return mPpm != rhs.mPpm; }
  constexpr bool operator!=(qint32 rhs) const { return mPpm != rhs; }
  explicit operator bool() const { return mPpm != 0; }

private:
  // Private Static Functions

  static qint32 normalizedStringToPpm(const QString& normalized);

  // Private Member Variables
  qint32 mPpm;  
};

/*******************************************************************************
 *  Non-Member Functions
 ******************************************************************************/

inline QDataStream& operator<<(QDataStream& stream, const Ratio& ratio) {
  stream << ratio.toNormalizedString();
  return stream;
}

inline QDebug operator<<(QDebug stream, const Ratio& ratio) {
  stream << QString("Ratio(%1%%°)").arg(ratio.toPercent());
  return stream;
}

inline QtCompat::Hash qHash(const Ratio& key,
                            QtCompat::Hash seed = 0) noexcept {
  return ::qHash(key.toPpm(), seed);
}

/*******************************************************************************
 *  Class UnsignedRatio
 ******************************************************************************/

struct UnsignedRatioVerifier {
  template <typename Value, typename Predicate>
  static constexpr auto verify(Value&& val, const Predicate& p) ->
      typename std::decay<Value>::type {
    return p(val) ? std::forward<Value>(val)
                  : (throw RuntimeError(__FILE__, __LINE__,
                                        Ratio::tr("Value must be >= 0!")),
                     std::forward<Value>(val));
  }
};

struct UnsignedRatioConstraint {
  constexpr bool operator()(const Ratio& r) const noexcept { return r >= 0; }
};

using UnsignedRatio =
    type_safe::constrained_type<Ratio, UnsignedRatioConstraint,
                                UnsignedRatioVerifier>;

inline QDataStream& operator<<(QDataStream& stream,
                               const UnsignedRatio& ratio) {
  stream << ratio->toNormalizedString();
  return stream;
}

inline QDebug operator<<(QDebug stream, const UnsignedRatio& ratio) {
  stream << QString("UnsignedRatio(%1%%)").arg(ratio->toPercent());
  return stream;
}

inline QtCompat::Hash qHash(const UnsignedRatio& key,
                            QtCompat::Hash seed = 0) noexcept {
  return ::qHash(key->toPpm(), seed);
}

/*******************************************************************************
 *  Class UnsignedLimitedRatio
 ******************************************************************************/

struct UnsignedLimitedRatioVerifier {
  template <typename Value, typename Predicate>
  static constexpr auto verify(Value&& val, const Predicate& p) ->
      typename std::decay<Value>::type {
    return p(val) ? std::forward<Value>(val)
                  : (throw RuntimeError(__FILE__, __LINE__,
                                        Ratio::tr("Value must be 0..1!")),
                     std::forward<Value>(val));
  }
};

struct UnsignedLimitedRatioConstraint {
  constexpr bool operator()(const Ratio& r) const noexcept {
    return (r >= 0) && (r <= Ratio::fromPercent(100));
  }
};

using UnsignedLimitedRatio =
    type_safe::constrained_type<Ratio, UnsignedLimitedRatioConstraint,
                                UnsignedLimitedRatioVerifier>;

inline QDataStream& operator<<(QDataStream& stream,
                               const UnsignedLimitedRatio& ratio) {
  stream << ratio->toNormalizedString();
  return stream;
}

inline QDebug operator<<(QDebug stream, const UnsignedLimitedRatio& ratio) {
  stream << QString("UnsignedLimitedRatio(%1%%)").arg(ratio->toPercent());
  return stream;
}

inline QtCompat::Hash qHash(const UnsignedLimitedRatio& key,
                            QtCompat::Hash seed = 0) noexcept {
  return ::qHash(key->toPpm(), seed);
}

/*******************************************************************************
 *  End of File
 ******************************************************************************/

}  // namespace librepcb

#endif