Format all code with clang-format

1 files changed, 187 insertions, 173 deletions

diff --git a/include/raul/TimeStamp.hpp b/include/raul/TimeStamp.hpp
index 01cc294..0385ef3 100644
--- a/include/raul/TimeStamp.hpp
+++ b/include/raul/TimeStamp.hpp
@@ -28,44 +28,46 @@ namespace Raul {
 /** A type of time stamp
  * \ingroup raul
  */
-class TimeUnit {
+class TimeUnit
+{
 public:
-	enum Type {
-		FRAMES,
-		BEATS,
-		SECONDS
-	};
-
-	/** `ppt` (parts per tick) is the sample rate for FRAMES, PPQN for BEATS,
-	 *  and ignored for SECONDS.
-	 */
-	inline TimeUnit(Type type, uint32_t ppt)
-		: _type(type)
-		, _ppt(ppt)
-	{
-		assert(type == SECONDS || ppt != 0);
-		_type = type;
-		_ppt = ppt;
-	}
-
-	static inline TimeUnit frames(uint32_t srate) { return {FRAMES, srate}; }
-	static inline TimeUnit beats(uint32_t ppqn)   { return {BEATS, ppqn}; }
-	static inline TimeUnit seconds()              { return {BEATS, std::numeric_limits<uint32_t>::max()}; }
-
-	inline Type     type() const { return _type; }
-	inline uint32_t ppt()  const { return _ppt; }
-
-	inline bool operator==(const TimeUnit& rhs) const {
-		return (_type == rhs._type && _ppt == rhs._ppt);
-	}
-
-	inline bool operator!=(const TimeUnit& rhs) const {
-		return (_type != rhs._type || _ppt != rhs._ppt);
-	}
+  enum Type { FRAMES, BEATS, SECONDS };
+
+  /** `ppt` (parts per tick) is the sample rate for FRAMES, PPQN for BEATS,
+   *  and ignored for SECONDS.
+   */
+  inline TimeUnit(Type type, uint32_t ppt)
+    : _type(type)
+    , _ppt(ppt)
+  {
+    assert(type == SECONDS || ppt != 0);
+    _type = type;
+    _ppt  = ppt;
+  }
+
+  static inline TimeUnit frames(uint32_t srate) { return {FRAMES, srate}; }
+  static inline TimeUnit beats(uint32_t ppqn) { return {BEATS, ppqn}; }
+  static inline TimeUnit seconds()
+  {
+    return {BEATS, std::numeric_limits<uint32_t>::max()};
+  }
+
+  inline Type     type() const { return _type; }
+  inline uint32_t ppt() const { return _ppt; }
+
+  inline bool operator==(const TimeUnit& rhs) const
+  {
+    return (_type == rhs._type && _ppt == rhs._ppt);
+  }
+
+  inline bool operator!=(const TimeUnit& rhs) const
+  {
+    return (_type != rhs._type || _ppt != rhs._ppt);
+  }
 
 private:
-	Type     _type;
-	uint32_t _ppt;
+  Type     _type;
+  uint32_t _ppt;
 };
 
 /** A real-time time stamp (possible units: frame, absolute (s), or beat).
@@ -77,158 +79,170 @@ private:
  *
  * \ingroup raul
  */
-class TimeStamp {
+class TimeStamp
+{
 public:
-	explicit TimeStamp(TimeUnit unit, uint32_t ticks = 0, uint32_t subticks = 0)
-		: _ticks(ticks)
-		, _subticks(subticks)
-		, _unit(unit)
-	{}
-
-	inline TimeStamp(TimeUnit unit, double dec)
-		: _ticks(0u)
-		, _subticks(0u)
-		, _unit(unit)
-	{
-		dec = std::max(0.0, dec);
-		dec = std::min(double(std::numeric_limits<uint32_t>::max()), dec);
-		double       integral   = 0.0;
-		const double fractional = modf(dec, &integral);
-		_ticks    = static_cast<uint32_t>(integral);
-		_subticks = static_cast<uint32_t>(fractional * unit.ppt());
-	}
-
-	TimeStamp(const TimeStamp&) = default;
-	TimeStamp& operator=(const TimeStamp&) = default;
-
-	TimeStamp(TimeStamp&&) = default;
-	TimeStamp& operator=(TimeStamp&&) = default;
-
-	~TimeStamp() = default;
-
-	inline TimeUnit unit()     const { return _unit; }
-	inline uint32_t ticks()    const { return _ticks; }
-	inline uint32_t subticks() const { return _subticks; }
-
-	inline double to_double() const {
-		return _ticks + (_subticks / static_cast<double>(_unit.ppt()));
-	}
-
-	inline bool is_zero() const {
-		return _ticks == 0 && _subticks == 0;
-	}
-
-	inline TimeStamp& operator=(uint32_t ticks) {
-		_ticks = ticks;
-		_subticks = 0;
-		return *this;
-	}
-
-	inline bool operator==(const TimeStamp& rhs) const {
-		return _ticks == rhs._ticks
-			&& _subticks == rhs._subticks
-			&& _unit == rhs._unit;
-	}
-
-	inline bool operator!=(const TimeStamp& rhs) const {
-		return !operator==(rhs);
-	}
-
-	inline bool operator<(const TimeStamp& rhs) const {
-		assert(_unit == rhs._unit);
-		return (_ticks < rhs._ticks
-				|| (_ticks == rhs._ticks && _subticks < rhs._subticks));
-	}
-
-	inline bool operator>(const TimeStamp& rhs) const {
-		assert(_unit == rhs._unit);
-		return (_ticks > rhs._ticks
-				|| (_ticks == rhs._ticks && _subticks > rhs._subticks));
-	}
-
-	inline bool operator<=(const TimeStamp& rhs) const {
-		return (*this == rhs) || ((*this) < rhs);
-	}
-
-	inline bool operator>=(const TimeStamp& rhs) const {
-		return (*this == rhs) || ((*this) > rhs);
-	}
-
-	inline TimeStamp& operator+=(const TimeStamp& rhs) {
-		assert(_unit == rhs._unit);
-		_ticks += rhs._ticks;
-		if (_subticks + rhs._subticks <= _unit.ppt()) {
-			_subticks += rhs._subticks;
-		} else if (rhs._subticks > 0) {
-			++_ticks;
-			_subticks = rhs._subticks + _subticks - _unit.ppt();
-		}
-		return *this;
-	}
-
-	inline TimeStamp& operator-=(const TimeStamp& rhs) {
-		assert(_unit == rhs._unit);
-		assert(rhs <= *this);
-		_ticks -= rhs._ticks;
-		if (_subticks >= rhs._subticks) {
-			_subticks -= rhs._subticks;
-		} else if (rhs._subticks > 0) {
-			--_ticks;
-			_subticks = _unit.ppt() - (rhs._subticks - _subticks);
-		}
-		return *this;
-	}
-
-	inline TimeStamp operator+(const TimeStamp& rhs) const {
-		assert(_unit == rhs._unit);
-		TimeStamp result = *this;
-		result += rhs;
-		return result;
-	}
-
-	inline TimeStamp operator-(const TimeStamp& rhs) const {
-		assert(_unit == rhs._unit);
-		TimeStamp result = *this;
-		result -= rhs;
-		return result;
-	}
+  explicit TimeStamp(TimeUnit unit, uint32_t ticks = 0, uint32_t subticks = 0)
+    : _ticks(ticks)
+    , _subticks(subticks)
+    , _unit(unit)
+  {}
+
+  inline TimeStamp(TimeUnit unit, double dec)
+    : _ticks(0u)
+    , _subticks(0u)
+    , _unit(unit)
+  {
+    dec = std::max(0.0, dec);
+    dec = std::min(double(std::numeric_limits<uint32_t>::max()), dec);
+    double       integral   = 0.0;
+    const double fractional = modf(dec, &integral);
+    _ticks                  = static_cast<uint32_t>(integral);
+    _subticks               = static_cast<uint32_t>(fractional * unit.ppt());
+  }
+
+  TimeStamp(const TimeStamp&) = default;
+  TimeStamp& operator=(const TimeStamp&) = default;
+
+  TimeStamp(TimeStamp&&) = default;
+  TimeStamp& operator=(TimeStamp&&) = default;
+
+  ~TimeStamp() = default;
+
+  inline TimeUnit unit() const { return _unit; }
+  inline uint32_t ticks() const { return _ticks; }
+  inline uint32_t subticks() const { return _subticks; }
+
+  inline double to_double() const
+  {
+    return _ticks + (_subticks / static_cast<double>(_unit.ppt()));
+  }
+
+  inline bool is_zero() const { return _ticks == 0 && _subticks == 0; }
+
+  inline TimeStamp& operator=(uint32_t ticks)
+  {
+    _ticks    = ticks;
+    _subticks = 0;
+    return *this;
+  }
+
+  inline bool operator==(const TimeStamp& rhs) const
+  {
+    return _ticks == rhs._ticks && _subticks == rhs._subticks &&
+           _unit == rhs._unit;
+  }
+
+  inline bool operator!=(const TimeStamp& rhs) const
+  {
+    return !operator==(rhs);
+  }
+
+  inline bool operator<(const TimeStamp& rhs) const
+  {
+    assert(_unit == rhs._unit);
+    return (_ticks < rhs._ticks ||
+            (_ticks == rhs._ticks && _subticks < rhs._subticks));
+  }
+
+  inline bool operator>(const TimeStamp& rhs) const
+  {
+    assert(_unit == rhs._unit);
+    return (_ticks > rhs._ticks ||
+            (_ticks == rhs._ticks && _subticks > rhs._subticks));
+  }
+
+  inline bool operator<=(const TimeStamp& rhs) const
+  {
+    return (*this == rhs) || ((*this) < rhs);
+  }
+
+  inline bool operator>=(const TimeStamp& rhs) const
+  {
+    return (*this == rhs) || ((*this) > rhs);
+  }
+
+  inline TimeStamp& operator+=(const TimeStamp& rhs)
+  {
+    assert(_unit == rhs._unit);
+    _ticks += rhs._ticks;
+    if (_subticks + rhs._subticks <= _unit.ppt()) {
+      _subticks += rhs._subticks;
+    } else if (rhs._subticks > 0) {
+      ++_ticks;
+      _subticks = rhs._subticks + _subticks - _unit.ppt();
+    }
+    return *this;
+  }
+
+  inline TimeStamp& operator-=(const TimeStamp& rhs)
+  {
+    assert(_unit == rhs._unit);
+    assert(rhs <= *this);
+    _ticks -= rhs._ticks;
+    if (_subticks >= rhs._subticks) {
+      _subticks -= rhs._subticks;
+    } else if (rhs._subticks > 0) {
+      --_ticks;
+      _subticks = _unit.ppt() - (rhs._subticks - _subticks);
+    }
+    return *this;
+  }
+
+  inline TimeStamp operator+(const TimeStamp& rhs) const
+  {
+    assert(_unit == rhs._unit);
+    TimeStamp result = *this;
+    result += rhs;
+    return result;
+  }
+
+  inline TimeStamp operator-(const TimeStamp& rhs) const
+  {
+    assert(_unit == rhs._unit);
+    TimeStamp result = *this;
+    result -= rhs;
+    return result;
+  }
 
 private:
-	uint32_t _ticks;
-	uint32_t _subticks;
-	TimeUnit _unit;
+  uint32_t _ticks;
+  uint32_t _subticks;
+  TimeUnit _unit;
 };
 
 inline std::ostream&
 operator<<(std::ostream& os, const TimeStamp& t)
 {
-	os << t.ticks() << ":" << t.subticks();
-	switch (t.unit().type()) {
-	case TimeUnit::FRAMES:
-		os << " frames";
-		break;
-	case TimeUnit::BEATS:
-		os << " beats";
-		break;
-	case TimeUnit::SECONDS:
-		os << " seconds";
-		break;
-	}
-	return os;
+  os << t.ticks() << ":" << t.subticks();
+  switch (t.unit().type()) {
+  case TimeUnit::FRAMES:
+    os << " frames";
+    break;
+  case TimeUnit::BEATS:
+    os << " beats";
+    break;
+  case TimeUnit::SECONDS:
+    os << " seconds";
+    break;
+  }
+  return os;
 }
 
-class FrameStamp : public TimeStamp {
+class FrameStamp : public TimeStamp
+{
 public:
-	explicit FrameStamp(uint32_t rate, uint32_t ticks = 0, uint32_t subticks = 0)
-		: TimeStamp(TimeUnit(TimeUnit::FRAMES, rate), ticks, subticks)
-	{}
+  explicit FrameStamp(uint32_t rate, uint32_t ticks = 0, uint32_t subticks = 0)
+    : TimeStamp(TimeUnit(TimeUnit::FRAMES, rate), ticks, subticks)
+  {}
 };
 
-class BeatStamp : public TimeStamp {
+class BeatStamp : public TimeStamp
+{
 public:
-	explicit BeatStamp(uint32_t ppqn, uint32_t ticks = 0, uint32_t subticks = 0)
-		: TimeStamp(TimeUnit(TimeUnit::BEATS, ppqn), ticks, subticks)
-	{}
+  explicit BeatStamp(uint32_t ppqn, uint32_t ticks = 0, uint32_t subticks = 0)
+    : TimeStamp(TimeUnit(TimeUnit::BEATS, ppqn), ticks, subticks)
+  {}
 };
 
 /** Same thing as TimeStamp really, but makes code clearer and enforces