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