Attachment #2798 for bug #2658

View | Details | Raw Unified | Return to bug 2658
Collapse All | Expand All




/**
 * Infix arithmetic operator for TracedValue.
 *
 * This returns the arithmetic result in its natural underlying raw data type.
 * which has no Callback connected.
 *
 * \tparam T \deduced The underlying type held by the left-hand argument.
 * \tparam U \deduced The underlying type held by the right-hand argument.

 *     the underlying values.
 */
template <typename T, typename U>
auto operator + (const TracedValue<T> &lhs, const TracedValue<U> &rhs) -> decltype(lhs.Get() + rhs.Get()) {
  TRACED_VALUE_DEBUG ("x+x");
  return lhs.Get () + rhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator + (const TracedValue<T> &lhs, const U &rhs) -> decltype(lhs.Get() + rhs) {
  TRACED_VALUE_DEBUG ("x+");
  return lhs.Get () + rhs;
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator + (const U &lhs, const TracedValue<T> &rhs) -> decltype(lhs + rhs.Get()) {
  TRACED_VALUE_DEBUG ("+x");
  return lhs + rhs.Get ();
}

/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator - (const TracedValue<T> &lhs, const TracedValue<U> &rhs) -> decltype(lhs.Get() - rhs.Get()) {
  TRACED_VALUE_DEBUG ("x-x");
  return lhs.Get () - rhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator - (const TracedValue<T> &lhs, const U &rhs) -> decltype(lhs.Get() - rhs) {
  TRACED_VALUE_DEBUG ("x-");
  return lhs.Get () - rhs;
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator - (const U &lhs, const TracedValue<T> &rhs) -> decltype(lhs - rhs.Get()) {
  TRACED_VALUE_DEBUG ("-x");
  return lhs - rhs.Get ();
}

/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator * (const TracedValue<T> &lhs, const TracedValue<U> &rhs) -> decltype(lhs.Get() * rhs.Get()) {
  TRACED_VALUE_DEBUG ("x*x");
  return lhs.Get () * rhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator * (const TracedValue<T> &lhs, const U &rhs) -> decltype(lhs.Get() * rhs) {
  TRACED_VALUE_DEBUG ("x*");
  return lhs.Get () * rhs;
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator * (const U &lhs, const TracedValue<T> &rhs) -> decltype(lhs + rhs.Get()) {
  TRACED_VALUE_DEBUG ("*x");
  return lhs * rhs.Get ();
}

/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator / (const TracedValue<T> &lhs, const TracedValue<U> &rhs) -> decltype(lhs.Get() / rhs.Get()) {
  TRACED_VALUE_DEBUG ("x/x");
  return lhs.Get () / rhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator / (const TracedValue<T> &lhs, const U &rhs) -> decltype(lhs.Get() / rhs) {
  TRACED_VALUE_DEBUG ("x/");
  return lhs.Get () / rhs;
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator / (const U &lhs, const TracedValue<T> &rhs) -> decltype(lhs / rhs.Get()) {
  TRACED_VALUE_DEBUG ("/x");
  return lhs / rhs.Get ();
}

/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator % (const TracedValue<T> &lhs, const TracedValue<U> &rhs) -> decltype(lhs.Get() % rhs.Get()) {
  TRACED_VALUE_DEBUG ("x%x");
  return lhs.Get () % rhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator % (const TracedValue<T> &lhs, const U &rhs) -> decltype(lhs.Get() % rhs) {
  TRACED_VALUE_DEBUG ("x%");
  return lhs.Get () % rhs;
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator % (const U &lhs, const TracedValue<T> &rhs) -> decltype(lhs % rhs.Get()) {
  TRACED_VALUE_DEBUG ("%x");
  return lhs % rhs.Get ();
}

/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator ^ (const TracedValue<T> &lhs, const TracedValue<U> &rhs) -> decltype(lhs.Get() ^ rhs.Get()) {
  TRACED_VALUE_DEBUG ("x^x");
  return lhs.Get () ^ rhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator ^ (const TracedValue<T> &lhs, const U &rhs) -> decltype(lhs.Get() ^ rhs) {
  TRACED_VALUE_DEBUG ("x^");
  return lhs.Get () ^ rhs;
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator ^ (const U &lhs, const TracedValue<T> &rhs) -> decltype(lhs ^ rhs.Get()) {
  TRACED_VALUE_DEBUG ("^x");
  return lhs ^ rhs.Get ();
}

/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator | (const TracedValue<T> &lhs, const TracedValue<U> &rhs) -> decltype(lhs.Get() | rhs.Get()) {
  TRACED_VALUE_DEBUG ("x|x");
  return lhs.Get () | rhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator | (const TracedValue<T> &lhs, const U &rhs) -> decltype(lhs.Get() | rhs) {
  TRACED_VALUE_DEBUG ("x|");
  return lhs.Get () | rhs;
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator | (const U &lhs, const TracedValue<T> &rhs) -> decltype(lhs | rhs.Get()) {
  TRACED_VALUE_DEBUG ("|x");
  return lhs | rhs.Get ();
}

/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator & (const TracedValue<T> &lhs, const TracedValue<U> &rhs) -> decltype(lhs.Get() & rhs.Get()) {
  TRACED_VALUE_DEBUG ("x&x");
  return lhs.Get () & rhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator & (const TracedValue<T> &lhs, const U &rhs) -> decltype(lhs.Get() & rhs) {
  TRACED_VALUE_DEBUG ("x&");
  return lhs.Get () & rhs;
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator & (const U &lhs, const TracedValue<T> &rhs) -> decltype(lhs & rhs.Get()) {
  TRACED_VALUE_DEBUG ("&x");
  return lhs & rhs.Get ();
}

/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator << (const TracedValue<T> &lhs, const TracedValue<U> &rhs) -> decltype(lhs.Get() << rhs.Get()) {
  TRACED_VALUE_DEBUG ("x<<x");
  return lhs.Get () << rhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator << (const TracedValue<T> &lhs, const U &rhs) -> decltype(lhs.Get() << rhs) {
  TRACED_VALUE_DEBUG ("x<<");
  return lhs.Get () << rhs;
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator << (const U &lhs, const TracedValue<T> &rhs) -> decltype(lhs << rhs.Get()) {
  TRACED_VALUE_DEBUG ("<<x");
  return lhs << rhs.Get ();
}

/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator >> (const TracedValue<T> &lhs, const TracedValue<U> &rhs) -> decltype(lhs.Get() >> rhs.Get()) {
  TRACED_VALUE_DEBUG ("x>>x");
  return lhs.Get () >> rhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator >> (const TracedValue<T> &lhs, const U &rhs) -> decltype(lhs.Get() >> rhs) {
  TRACED_VALUE_DEBUG ("x>>");
  return lhs.Get () >> rhs;
}
/** \copydoc operator+(const TracedValue<T>&lhs,const TracedValue<U>&rhs) */
template <typename T, typename U>
auto operator >> (const U &lhs, const TracedValue<T> &rhs) -> decltype(lhs >> rhs.Get()) {
  TRACED_VALUE_DEBUG (">>x");
  return lhs >> rhs.Get ();
}

/**

 *     the underlying values.
 */
template <typename T>
T operator + (const TracedValue<T> &lhs) {
  TRACED_VALUE_DEBUG ("(+x)");
  return +lhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs) */
template <typename T>
T operator - (const TracedValue<T> &lhs) {
  TRACED_VALUE_DEBUG ("(-x)");
  return -lhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs) */
template <typename T>
T operator ~ (const TracedValue<T> &lhs) {
  TRACED_VALUE_DEBUG ("(~x)");
  return ~lhs.Get ();
}
/** \copydoc operator+(const TracedValue<T>&lhs) */
template <typename T>
T operator ! (const TracedValue<T> &lhs) {
  TRACED_VALUE_DEBUG ("(!x)");
  return !lhs.Get ();
}

/**@}*/  // \ingroup tracing

Return to bug 2658