From a7aed07a5b620977fb74e4070e432eef01d11d3c Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Tue, 27 Aug 2013 13:41:19 -0700 Subject: broke out llunit.h into llunittype.h and llunits.h for unit declarations changed unit declarations macros to make a lot more sense --- indra/llcommon/llunittype.h | 734 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 734 insertions(+) create mode 100644 indra/llcommon/llunittype.h (limited to 'indra/llcommon/llunittype.h') diff --git a/indra/llcommon/llunittype.h b/indra/llcommon/llunittype.h new file mode 100644 index 0000000000..949e4492c7 --- /dev/null +++ b/indra/llcommon/llunittype.h @@ -0,0 +1,734 @@ +/** + * @file llunit.h + * @brief Unit conversion classes + * + * $LicenseInfo:firstyear=2001&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2012, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#ifndef LL_UNITTYPE_H +#define LL_UNITTYPE_H + +#include "stdtypes.h" +#include "llpreprocessor.h" +#include "llerror.h" + +//lightweight replacement of type traits for simple type equality check +template +struct LLIsSameType +{ + static const bool value = false; +}; + +template +struct LLIsSameType +{ + static const bool value = true; +}; + +// workaround for decltype() not existing and typeof() not working inline in gcc 4.2 +template +struct LLResultTypeAdd +{ + typedef LL_TYPEOF(S() + T()) type_t; +}; + +template +struct LLResultTypeSubtract +{ + typedef LL_TYPEOF(S() - T()) type_t; +}; + +template +struct LLResultTypeMultiply +{ + typedef LL_TYPEOF(S() * T()) type_t; +}; + +template +struct LLResultTypeDivide +{ + typedef LL_TYPEOF(S() / T(1)) type_t; +}; + +template +struct LLResultTypePromote +{ + typedef LL_TYPEOF((true) ? S() : T()) type_t; +}; + +template +struct LLUnit +{ + typedef LLUnit self_t; + typedef STORAGE_TYPE storage_t; + + // value initialization + LL_FORCE_INLINE explicit LLUnit(storage_t value = storage_t()) + : mValue(value) + {} + + // unit initialization and conversion + template + LL_FORCE_INLINE LLUnit(LLUnit other) + : mValue(convert(other).mValue) + {} + + storage_t value() const + { + return mValue; + } + + void value(storage_t value) + { + mValue = value; + } + + template + storage_t valueInUnits() + { + return LLUnit(*this).value(); + } + + template + void valueInUnits(storage_t value) + { + *this = LLUnit(value); + } + + void operator += (self_t other) + { + mValue += convert(other).mValue; + } + + void operator -= (self_t other) + { + mValue -= convert(other).mValue; + } + + void operator *= (storage_t multiplicand) + { + mValue *= multiplicand; + } + + void operator *= (self_t multiplicand) + { + // spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template + LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "Multiplication of unit types not supported."); + } + + void operator /= (storage_t divisor) + { + mValue /= divisor; + } + + void operator /= (self_t divisor) + { + // spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template + LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "Illegal in-place division of unit types."); + } + + template + LL_FORCE_INLINE static self_t convert(LLUnit v) + { + typedef typename LLResultTypePromote::type_t result_storage_t; + LLUnit result; + result_storage_t divisor = ll_convert_units(v, result); + result.value(result.value() / divisor); + return self_t(result.value()); + } + +protected: + storage_t mValue; +}; + +template +std::ostream& operator <<(std::ostream& s, const LLUnit& unit) +{ + s << unit.value() << UNIT_TYPE::getUnitLabel(); + return s; +} + +template +std::istream& operator >>(std::istream& s, LLUnit& unit) +{ + STORAGE_TYPE val; + s >> val; + unit.value(val); + return s; +} + +template +struct LLUnitImplicit : public LLUnit +{ + typedef LLUnitImplicit self_t; + typedef typename LLUnit::storage_t storage_t; + typedef LLUnit base_t; + + LLUnitImplicit(storage_t value = storage_t()) + : base_t(value) + {} + + template + LLUnitImplicit(LLUnit other) + : base_t(other) + {} + + // unlike LLUnit, LLUnitImplicit is *implicitly* convertable to a POD value (F32, S32, etc) + // this allows for interoperability with legacy code + operator storage_t() const + { + return base_t::value(); + } + + using base_t::operator +=; + void operator += (storage_t value) + { + base_t::mValue += value; + } + + // this overload exists to explicitly catch use of another implicit unit + // without ambiguity between conversion to storage_t vs conversion to base_t + template + void operator += (LLUnitImplicit other) + { + base_t::mValue += convert(other).value(); + } + + using base_t::operator -=; + void operator -= (storage_t value) + { + base_t::mValue -= value; + } + + // this overload exists to explicitly catch use of another implicit unit + // without ambiguity between conversion to storage_t vs conversion to base_t + template + void operator -= (LLUnitImplicit other) + { + base_t::mValue -= convert(other).value(); + } + +}; + +template +std::ostream& operator <<(std::ostream& s, const LLUnitImplicit& unit) +{ + s << unit.value() << UNIT_TYPE::getUnitLabel(); + return s; +} + +template +std::istream& operator >>(std::istream& s, LLUnitImplicit& unit) +{ + STORAGE_TYPE val; + s >> val; + unit = val; + return s; +} + +template +LL_FORCE_INLINE S2 ll_convert_units(LLUnit in, LLUnit& out) +{ + S2 divisor(1); + + LL_STATIC_ASSERT((LLIsSameType::value + || !LLIsSameType::value + || !LLIsSameType::value), + "conversion requires compatible units"); + + if (LLIsSameType::value) + { + // T1 and T2 same type, just assign + out.value((S2)in.value()); + } + else if (T1::sLevel > T2::sLevel) + { + // reduce T1 + LLUnit new_in; + divisor *= (S2)ll_convert_units(in, new_in); + divisor *= (S2)ll_convert_units(new_in, out); + } + else + { + // reduce T2 + LLUnit new_out; + divisor *= (S2)ll_convert_units(in, new_out); + divisor *= (S2)ll_convert_units(new_out, out); + } + return divisor; +} + +template +struct LLStorageType +{ + typedef T type_t; +}; + +template +struct LLStorageType > +{ + typedef STORAGE_TYPE type_t; +}; + +// all of these operators need to perform type promotion on the storage type of the units, so they +// cannot be expressed as operations on identical types with implicit unit conversion +// e.g. typeof(S32Bytes(x) + F32Megabytes(y)) <==> F32Bytes + +// +// operator + +// +template +LLUnit::type_t, UNIT_TYPE1> operator + (LLUnit first, LLUnit second) +{ + LLUnit::type_t, UNIT_TYPE1> result(first); + result += second; + return result; +} + +template +LLUnit operator + (LLUnit first, UNITLESS second) +{ + LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "operator + requires compatible unit types"); + return LLUnit(0); +} + +template +LLUnit operator + (UNITLESS first, LLUnit second) +{ + LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "operator + requires compatible unit types"); + return LLUnit(0); +} + +template +LLUnitImplicit::type_t, UNIT_TYPE1> operator + (LLUnitImplicit first, LLUnitImplicit second) +{ + LLUnitImplicit::type_t, UNIT_TYPE1> result(first); + result += second; + return result; +} + +template +LLUnitImplicit::type_t, UNIT_TYPE1> operator + (LLUnit first, LLUnitImplicit second) +{ + LLUnitImplicit::type_t, UNIT_TYPE1> result(first); + result += second; + return result; +} + +template +LLUnitImplicit::type_t, UNIT_TYPE1> operator + (LLUnitImplicit first, LLUnit second) +{ + LLUnitImplicit::type_t, UNIT_TYPE1> result(first); + result += LLUnitImplicit(second); + return result; +} + +template +LLUnitImplicit::type_t>::type_t, UNIT_TYPE> operator + (LLUnitImplicit first, UNITLESS_TYPE second) +{ + LLUnitImplicit::type_t>::type_t, UNIT_TYPE> result(first); + result += second; + return result; +} + +template +LLUnitImplicit::type_t, STORAGE_TYPE>:: + type_t, UNIT_TYPE> operator + (UNITLESS_TYPE first, LLUnitImplicit second) +{ + LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE> result(first); + result += second; + return result; +} + +// +// operator - +// +template +LLUnit::type_t, UNIT_TYPE1> operator - (LLUnit first, LLUnit second) +{ + LLUnit::type_t, UNIT_TYPE1> result(first); + result -= second; + return result; +} + +template +LLUnit operator - (LLUnit first, UNITLESS second) +{ + LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "operator - requires compatible unit types"); + return LLUnit(0); +} + +template +LLUnit operator - (UNITLESS first, LLUnit second) +{ + LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "operator - requires compatible unit types"); + return LLUnit(0); +} + +template +LLUnitImplicit::type_t, UNIT_TYPE1> operator - (LLUnitImplicit first, LLUnitImplicit second) +{ + LLUnitImplicit::type_t, UNIT_TYPE1> result(first); + result -= second; + return result; +} + +template +LLUnitImplicit::type_t, UNIT_TYPE1> operator - (LLUnit first, LLUnitImplicit second) +{ + LLUnitImplicit::type_t, UNIT_TYPE1> result(first); + result -= second; + return result; +} + +template +LLUnitImplicit::type_t, UNIT_TYPE1> operator - (LLUnitImplicit first, LLUnit second) +{ + LLUnitImplicit::type_t, UNIT_TYPE1> result(first); + result -= LLUnitImplicit(second); + return result; +} + +template +LLUnitImplicit::type_t>::type_t, UNIT_TYPE> operator - (LLUnitImplicit first, UNITLESS_TYPE second) +{ + LLUnitImplicit::type_t>::type_t, UNIT_TYPE> result(first); + result -= second; + return result; +} + +template +LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE> operator - (UNITLESS_TYPE first, LLUnitImplicit second) +{ + LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE> result(first); + result -= second; + return result; +} + +// +// operator * +// +template +LLUnit operator * (LLUnit, LLUnit) +{ + // spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template + LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE1, "multiplication of unit types results in new unit type - not supported."); + return LLUnit(); +} + +template +LLUnit::type_t>::type_t, UNIT_TYPE> operator * (LLUnit first, UNITLESS_TYPE second) +{ + return LLUnit::type_t>::type_t, UNIT_TYPE>(first.value() * second); +} + +template +LLUnit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE> operator * (UNITLESS_TYPE first, LLUnit second) +{ + return LLUnit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE>(first * second.value()); +} + +template +LLUnitImplicit operator * (LLUnitImplicit, LLUnitImplicit) +{ + // spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template + LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE1, "multiplication of unit types results in new unit type - not supported."); + return LLUnitImplicit(); +} + +template +LLUnitImplicit::type_t>::type_t, UNIT_TYPE> operator * (LLUnitImplicit first, UNITLESS_TYPE second) +{ + return LLUnitImplicit::type_t, UNIT_TYPE>(first.value() * second); +} + +template +LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE> operator * (UNITLESS_TYPE first, LLUnitImplicit second) +{ + return LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE>(first * second.value()); +} + + +// +// operator / +// + +template +LLUnit::type_t>::type_t, UNIT_TYPE> operator / (LLUnit first, UNITLESS_TYPE second) +{ + return LLUnit::type_t>::type_t, UNIT_TYPE>(first.value() / second); +} + +template +typename LLResultTypeDivide::type_t operator / (LLUnit first, LLUnit second) +{ + return first.value() / first.convert(second).value(); +} + +template +LLUnitImplicit::type_t>::type_t, UNIT_TYPE> operator / (LLUnitImplicit first, UNITLESS_TYPE second) +{ + return LLUnitImplicit::type_t>::type_t, UNIT_TYPE>(first.value() / second); +} + +template +typename LLResultTypeDivide::type_t operator / (LLUnitImplicit first, LLUnitImplicit second) +{ + return (typename LLResultTypeDivide::type_t)(first.value() / first.convert(second).value()); +} + +template +typename LLResultTypeDivide::type_t operator / (LLUnit first, LLUnitImplicit second) +{ + return (typename LLResultTypeDivide::type_t)(first.value() / first.convert(second).value()); +} + +template +typename LLResultTypeDivide::type_t operator / (LLUnitImplicit first, LLUnit second) +{ + return (typename LLResultTypeDivide::type_t)(first.value() / first.convert(second).value()); +} + +// +// comparison operators +// + +#define LL_UNIT_DECLARE_COMPARISON_OPERATOR(op) \ +template \ +bool operator op (LLUnitImplicit first, LLUnitImplicit second) \ +{ \ + return first.value() op first.convert(second).value(); \ +} \ + \ +template \ +bool operator op (LLUnitImplicit first, UNITLESS_TYPE second) \ +{ \ + return first.value() op second; \ +} \ + \ +template \ +bool operator op (UNITLESS_TYPE first, LLUnitImplicit second) \ +{ \ + return first op second.value(); \ +} \ + \ +template \ +bool operator op (LLUnit first, LLUnit second) \ +{ \ + return first.value() op first.convert(second).value(); \ +} \ + \ +template \ +bool operator op (LLUnit first, UNITLESS_TYPE second) \ +{ \ + LL_BAD_TEMPLATE_INSTANTIATION(UNITLESS_TYPE, "operator " #op " requires compatible unit types"); \ + return false; \ +} \ + \ +template \ +bool operator op (UNITLESS_TYPE first, LLUnit second) \ +{ \ + LL_BAD_TEMPLATE_INSTANTIATION(UNITLESS_TYPE, "operator " #op " requires compatible unit types"); \ + return false; \ +} \ + \ +template \ +bool operator op (LLUnit first, LLUnitImplicit second) \ +{ \ + return first.value() op first.convert(second).value(); \ +} \ + \ +template \ +bool operator op (LLUnitImplicit first, LLUnit second) \ +{ \ + return first.value() op first.convert(second).value(); \ +} + +LL_UNIT_DECLARE_COMPARISON_OPERATOR(<); +LL_UNIT_DECLARE_COMPARISON_OPERATOR(<=); +LL_UNIT_DECLARE_COMPARISON_OPERATOR(>); +LL_UNIT_DECLARE_COMPARISON_OPERATOR(>=); +LL_UNIT_DECLARE_COMPARISON_OPERATOR(==); +LL_UNIT_DECLARE_COMPARISON_OPERATOR(!=); + + +template +struct LLGetUnitLabel +{ + static const char* getUnitLabel() { return ""; } +}; + +template +struct LLGetUnitLabel > +{ + static const char* getUnitLabel() { return T::getUnitLabel(); } +}; + +template +struct LLUnitLinearOps +{ + typedef LLUnitLinearOps self_t; + + LLUnitLinearOps(T val) + : mValue(val), + mDivisor(1) + {} + + template + self_t operator * (OTHER_T other) + { + return mValue * other; + } + + template + self_t operator / (OTHER_T other) + { + mDivisor *= other; + return *this; + } + + template + self_t operator + (OTHER_T other) + { + mValue /= mDivisor; + mValue += other; + return *this; + } + + template + self_t operator - (OTHER_T other) + { + mValue /= mDivisor; + mValue -= other; + return *this; + } + + T mValue; + T mDivisor; +}; + +template +struct LLUnitInverseLinearOps +{ + typedef LLUnitInverseLinearOps self_t; + + LLUnitInverseLinearOps(T val) + : mValue(val), + mDivisor(1) + {} + + template + self_t operator * (OTHER_T other) + { + mDivisor *= other; + return *this; + } + + template + self_t operator / (OTHER_T other) + { + mValue *= other; + return *this; + } + + template + self_t operator + (OTHER_T other) + { + mValue /= mDivisor; + mValue -= other; + return *this; + } + + template + self_t operator - (OTHER_T other) + { + mValue /= mDivisor; + mValue += other; + return *this; + } + + T mValue; + T mDivisor; +}; + +#define LL_DECLARE_BASE_UNIT(base_unit_name, unit_label) \ +struct base_unit_name \ +{ \ + static const int sLevel = 0; \ + typedef base_unit_name base_unit_t; \ + static const char* getUnitLabel() { return unit_label; } \ + template \ + static LLUnit fromValue(T value) { return LLUnit(value); } \ + template \ + static LLUnit fromValue(LLUnit value) \ + { return LLUnit(value); } \ +} + + +#define LL_DECLARE_DERIVED_UNIT(unit_name, unit_label, base_unit_name, conversion_operation) \ +struct unit_name \ +{ \ + static const int sLevel = base_unit_name::sLevel + 1; \ + typedef base_unit_name base_unit_t; \ + static const char* getUnitLabel() { return unit_label; } \ + template \ + static LLUnit fromValue(T value) { return LLUnit(value); } \ + template \ + static LLUnit fromValue(LLUnit value) \ + { return LLUnit(value); } \ +}; \ + \ +template \ +LL_FORCE_INLINE S2 ll_convert_units(LLUnit in, LLUnit& out) \ +{ \ + typedef typename LLResultTypePromote::type_t result_storage_t; \ + LLUnitInverseLinearOps op = \ + LLUnitInverseLinearOps(in.value()) conversion_operation; \ + out = LLUnit((S2)op.mValue); \ + return op.mDivisor; \ +} \ + \ +template \ +LL_FORCE_INLINE S2 ll_convert_units(LLUnit in, LLUnit& out) \ +{ \ + typedef typename LLResultTypePromote::type_t result_storage_t; \ + LLUnitLinearOps op = \ + LLUnitLinearOps(in.value()) conversion_operation; \ + out = LLUnit((S2)op.mValue); \ + return op.mDivisor; \ +} + +#define LL_DECLARE_UNIT_TYPEDEFS(ns, unit_name) \ + typedef LLUnit F32##unit_name; \ + typedef LLUnitImplicit F32##unit_name##Implicit;\ + typedef LLUnit F64##unit_name; \ + typedef LLUnitImplicit F64##unit_name##Implicit;\ + typedef LLUnit S32##unit_name; \ + typedef LLUnitImplicit S32##unit_name##Implicit;\ + typedef LLUnit S64##unit_name; \ + typedef LLUnitImplicit S64##unit_name##Implicit;\ + typedef LLUnit U32##unit_name; \ + typedef LLUnitImplicit U32##unit_name##Implicit;\ + typedef LLUnit U64##unit_name; \ + typedef LLUnitImplicit U64##unit_name##Implicit + +#endif //LL_UNITTYPE_H -- cgit v1.2.3 From 014969690bed06d77cc2e08efbd2dc9b71fb0cd2 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Tue, 27 Aug 2013 16:04:15 -0700 Subject: shuffled things around to get MSVC optimizer to generate optimal code in particular, created shortcut overloads for conversions and moved comparison operators into member functions --- indra/llcommon/llunittype.h | 445 +++++++++++++++++++++++++------------------- 1 file changed, 253 insertions(+), 192 deletions(-) (limited to 'indra/llcommon/llunittype.h') diff --git a/indra/llcommon/llunittype.h b/indra/llcommon/llunittype.h index 949e4492c7..a5e99070b6 100644 --- a/indra/llcommon/llunittype.h +++ b/indra/llcommon/llunittype.h @@ -75,10 +75,10 @@ struct LLResultTypePromote typedef LL_TYPEOF((true) ? S() : T()) type_t; }; -template +template struct LLUnit { - typedef LLUnit self_t; + typedef LLUnit self_t; typedef STORAGE_TYPE storage_t; // value initialization @@ -87,55 +87,55 @@ struct LLUnit {} // unit initialization and conversion - template - LL_FORCE_INLINE LLUnit(LLUnit other) + template + LL_FORCE_INLINE LLUnit(LLUnit other) : mValue(convert(other).mValue) {} - storage_t value() const + LL_FORCE_INLINE storage_t value() const { return mValue; } - void value(storage_t value) + LL_FORCE_INLINE void value(storage_t value) { mValue = value; } - template + template storage_t valueInUnits() { - return LLUnit(*this).value(); + return LLUnit(*this).value(); } - template + template void valueInUnits(storage_t value) { - *this = LLUnit(value); + *this = LLUnit(value); } - void operator += (self_t other) + LL_FORCE_INLINE void operator += (self_t other) { mValue += convert(other).mValue; } - void operator -= (self_t other) + LL_FORCE_INLINE void operator -= (self_t other) { mValue -= convert(other).mValue; } - void operator *= (storage_t multiplicand) + LL_FORCE_INLINE void operator *= (storage_t multiplicand) { mValue *= multiplicand; } - void operator *= (self_t multiplicand) + LL_FORCE_INLINE void operator *= (self_t multiplicand) { // spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "Multiplication of unit types not supported."); } - void operator /= (storage_t divisor) + LL_FORCE_INLINE void operator /= (storage_t divisor) { mValue /= divisor; } @@ -146,11 +146,58 @@ struct LLUnit LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "Illegal in-place division of unit types."); } - template - LL_FORCE_INLINE static self_t convert(LLUnit v) + template + LL_FORCE_INLINE bool operator == (LLUnit other) + { + return mValue == convert(other).value(); + } + + template + LL_FORCE_INLINE bool operator != (LLUnit other) + { + return mValue != convert(other).value(); + } + + template + LL_FORCE_INLINE bool operator < (LLUnit other) + { + return mValue < convert(other).value(); + } + + template + LL_FORCE_INLINE bool operator <= (LLUnit other) + { + return mValue <= convert(other).value(); + } + template + LL_FORCE_INLINE bool operator > (LLUnit other) + { + return mValue > convert(other).value(); + } + template + LL_FORCE_INLINE bool operator >= (LLUnit other) + { + return mValue >= convert(other).value(); + } + + LL_FORCE_INLINE static self_t convert(self_t v) { - typedef typename LLResultTypePromote::type_t result_storage_t; - LLUnit result; + return v; + } + + template + LL_FORCE_INLINE static self_t convert(LLUnit v) + { + self_t result; + result.mValue = (STORAGE_TYPE)v.value(); + return result; + } + + template + LL_FORCE_INLINE static self_t convert(LLUnit v) + { + typedef typename LLResultTypePromote::type_t result_storage_t; + LLUnit result; result_storage_t divisor = ll_convert_units(v, result); result.value(result.value() / divisor); return self_t(result.value()); @@ -160,15 +207,15 @@ protected: storage_t mValue; }; -template -std::ostream& operator <<(std::ostream& s, const LLUnit& unit) +template +std::ostream& operator <<(std::ostream& s, const LLUnit& unit) { - s << unit.value() << UNIT_TYPE::getUnitLabel(); + s << unit.value() << UNITS::getUnitLabel(); return s; } -template -std::istream& operator >>(std::istream& s, LLUnit& unit) +template +std::istream& operator >>(std::istream& s, LLUnit& unit) { STORAGE_TYPE val; s >> val; @@ -176,68 +223,145 @@ std::istream& operator >>(std::istream& s, LLUnit& unit return s; } -template -struct LLUnitImplicit : public LLUnit +template +struct LLUnitImplicit : public LLUnit { - typedef LLUnitImplicit self_t; - typedef typename LLUnit::storage_t storage_t; - typedef LLUnit base_t; + typedef LLUnitImplicit self_t; + typedef typename LLUnit::storage_t storage_t; + typedef LLUnit base_t; - LLUnitImplicit(storage_t value = storage_t()) + LL_FORCE_INLINE LLUnitImplicit(storage_t value = storage_t()) : base_t(value) {} - template - LLUnitImplicit(LLUnit other) + template + LL_FORCE_INLINE LLUnitImplicit(LLUnit other) : base_t(other) {} // unlike LLUnit, LLUnitImplicit is *implicitly* convertable to a POD value (F32, S32, etc) // this allows for interoperability with legacy code - operator storage_t() const + LL_FORCE_INLINE operator storage_t() const { return base_t::value(); } using base_t::operator +=; - void operator += (storage_t value) + LL_FORCE_INLINE void operator += (storage_t value) { base_t::mValue += value; } // this overload exists to explicitly catch use of another implicit unit // without ambiguity between conversion to storage_t vs conversion to base_t - template - void operator += (LLUnitImplicit other) + template + LL_FORCE_INLINE void operator += (LLUnitImplicit other) { base_t::mValue += convert(other).value(); } using base_t::operator -=; - void operator -= (storage_t value) + LL_FORCE_INLINE void operator -= (storage_t value) { base_t::mValue -= value; } // this overload exists to explicitly catch use of another implicit unit // without ambiguity between conversion to storage_t vs conversion to base_t - template - void operator -= (LLUnitImplicit other) + template + LL_FORCE_INLINE void operator -= (LLUnitImplicit other) { base_t::mValue -= convert(other).value(); } + using base_t::operator ==; + template + LL_FORCE_INLINE bool operator == (LLUnitImplicit other) + { + return mValue == convert(other).value(); + } + + template + LL_FORCE_INLINE bool operator == (STORAGE_T other) + { + return mValue == other; + } + + using base_t::operator !=; + template + LL_FORCE_INLINE bool operator != (LLUnitImplicit other) + { + return mValue != convert(other).value(); + } + + template + LL_FORCE_INLINE bool operator != (STORAGE_T other) + { + return mValue != other; + } + + using base_t::operator <; + template + LL_FORCE_INLINE bool operator < (LLUnitImplicit other) + { + return mValue < convert(other).value(); + } + + template + LL_FORCE_INLINE bool operator < (STORAGE_T other) + { + return mValue < other; + } + + using base_t::operator <=; + template + LL_FORCE_INLINE bool operator <= (LLUnitImplicit other) + { + return mValue <= convert(other).value(); + } + + template + LL_FORCE_INLINE bool operator <= (STORAGE_T other) + { + return mValue <= other; + } + + using base_t::operator >; + template + LL_FORCE_INLINE bool operator > (LLUnitImplicit other) + { + return mValue > convert(other).value(); + } + + template + LL_FORCE_INLINE bool operator > (STORAGE_T other) + { + return mValue > other; + } + + using base_t::operator >=; + template + LL_FORCE_INLINE bool operator >= (LLUnitImplicit other) + { + return mValue >= convert(other).value(); + } + + template + LL_FORCE_INLINE bool operator >= (STORAGE_T other) + { + return mValue >= other; + } }; -template -std::ostream& operator <<(std::ostream& s, const LLUnitImplicit& unit) +template +std::ostream& operator <<(std::ostream& s, const LLUnitImplicit& unit) { - s << unit.value() << UNIT_TYPE::getUnitLabel(); + s << unit.value() << UNITS::getUnitLabel(); return s; } -template -std::istream& operator >>(std::istream& s, LLUnitImplicit& unit) +template +std::istream& operator >>(std::istream& s, LLUnitImplicit& unit) { STORAGE_TYPE val; s >> val; @@ -283,8 +407,8 @@ struct LLStorageType typedef T type_t; }; -template -struct LLStorageType > +template +struct LLStorageType > { typedef STORAGE_TYPE type_t; }; @@ -296,65 +420,65 @@ struct LLStorageType > // // operator + // -template -LLUnit::type_t, UNIT_TYPE1> operator + (LLUnit first, LLUnit second) +template +LL_FORCE_INLINE LLUnit::type_t, UNITS1> operator + (LLUnit first, LLUnit second) { - LLUnit::type_t, UNIT_TYPE1> result(first); + LLUnit::type_t, UNITS1> result(first); result += second; return result; } -template -LLUnit operator + (LLUnit first, UNITLESS second) +template +LLUnit operator + (LLUnit first, UNITLESS second) { LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "operator + requires compatible unit types"); - return LLUnit(0); + return LLUnit(0); } -template -LLUnit operator + (UNITLESS first, LLUnit second) +template +LLUnit operator + (UNITLESS first, LLUnit second) { LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "operator + requires compatible unit types"); - return LLUnit(0); + return LLUnit(0); } -template -LLUnitImplicit::type_t, UNIT_TYPE1> operator + (LLUnitImplicit first, LLUnitImplicit second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t, UNITS1> operator + (LLUnitImplicit first, LLUnitImplicit second) { - LLUnitImplicit::type_t, UNIT_TYPE1> result(first); + LLUnitImplicit::type_t, UNITS1> result(first); result += second; return result; } -template -LLUnitImplicit::type_t, UNIT_TYPE1> operator + (LLUnit first, LLUnitImplicit second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t, UNITS1> operator + (LLUnit first, LLUnitImplicit second) { - LLUnitImplicit::type_t, UNIT_TYPE1> result(first); + LLUnitImplicit::type_t, UNITS1> result(first); result += second; return result; } -template -LLUnitImplicit::type_t, UNIT_TYPE1> operator + (LLUnitImplicit first, LLUnit second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t, UNITS1> operator + (LLUnitImplicit first, LLUnit second) { - LLUnitImplicit::type_t, UNIT_TYPE1> result(first); - result += LLUnitImplicit(second); + LLUnitImplicit::type_t, UNITS1> result(first); + result += LLUnitImplicit(second); return result; } -template -LLUnitImplicit::type_t>::type_t, UNIT_TYPE> operator + (LLUnitImplicit first, UNITLESS_TYPE second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t>::type_t, UNITS> operator + (LLUnitImplicit first, UNITLESS_TYPE second) { - LLUnitImplicit::type_t>::type_t, UNIT_TYPE> result(first); + LLUnitImplicit::type_t>::type_t, UNITS> result(first); result += second; return result; } -template -LLUnitImplicit::type_t, STORAGE_TYPE>:: - type_t, UNIT_TYPE> operator + (UNITLESS_TYPE first, LLUnitImplicit second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t, STORAGE_TYPE>:: + type_t, UNITS> operator + (UNITLESS_TYPE first, LLUnitImplicit second) { - LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE> result(first); + LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNITS> result(first); result += second; return result; } @@ -362,64 +486,64 @@ LLUnitImplicit::t // // operator - // -template -LLUnit::type_t, UNIT_TYPE1> operator - (LLUnit first, LLUnit second) +template +LL_FORCE_INLINE LLUnit::type_t, UNITS1> operator - (LLUnit first, LLUnit second) { - LLUnit::type_t, UNIT_TYPE1> result(first); + LLUnit::type_t, UNITS1> result(first); result -= second; return result; } -template -LLUnit operator - (LLUnit first, UNITLESS second) +template +LLUnit operator - (LLUnit first, UNITLESS second) { LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "operator - requires compatible unit types"); - return LLUnit(0); + return LLUnit(0); } -template -LLUnit operator - (UNITLESS first, LLUnit second) +template +LLUnit operator - (UNITLESS first, LLUnit second) { LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE, "operator - requires compatible unit types"); - return LLUnit(0); + return LLUnit(0); } -template -LLUnitImplicit::type_t, UNIT_TYPE1> operator - (LLUnitImplicit first, LLUnitImplicit second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t, UNITS1> operator - (LLUnitImplicit first, LLUnitImplicit second) { - LLUnitImplicit::type_t, UNIT_TYPE1> result(first); + LLUnitImplicit::type_t, UNITS1> result(first); result -= second; return result; } -template -LLUnitImplicit::type_t, UNIT_TYPE1> operator - (LLUnit first, LLUnitImplicit second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t, UNITS1> operator - (LLUnit first, LLUnitImplicit second) { - LLUnitImplicit::type_t, UNIT_TYPE1> result(first); + LLUnitImplicit::type_t, UNITS1> result(first); result -= second; return result; } -template -LLUnitImplicit::type_t, UNIT_TYPE1> operator - (LLUnitImplicit first, LLUnit second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t, UNITS1> operator - (LLUnitImplicit first, LLUnit second) { - LLUnitImplicit::type_t, UNIT_TYPE1> result(first); - result -= LLUnitImplicit(second); + LLUnitImplicit::type_t, UNITS1> result(first); + result -= LLUnitImplicit(second); return result; } -template -LLUnitImplicit::type_t>::type_t, UNIT_TYPE> operator - (LLUnitImplicit first, UNITLESS_TYPE second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t>::type_t, UNITS> operator - (LLUnitImplicit first, UNITLESS_TYPE second) { - LLUnitImplicit::type_t>::type_t, UNIT_TYPE> result(first); + LLUnitImplicit::type_t>::type_t, UNITS> result(first); result -= second; return result; } -template -LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE> operator - (UNITLESS_TYPE first, LLUnitImplicit second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNITS> operator - (UNITLESS_TYPE first, LLUnitImplicit second) { - LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE> result(first); + LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNITS> result(first); result -= second; return result; } @@ -427,44 +551,44 @@ LLUnitImplicit -LLUnit operator * (LLUnit, LLUnit) +template +LLUnit operator * (LLUnit, LLUnit) { // spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE1, "multiplication of unit types results in new unit type - not supported."); - return LLUnit(); + return LLUnit(); } -template -LLUnit::type_t>::type_t, UNIT_TYPE> operator * (LLUnit first, UNITLESS_TYPE second) +template +LL_FORCE_INLINE LLUnit::type_t>::type_t, UNITS> operator * (LLUnit first, UNITLESS_TYPE second) { - return LLUnit::type_t>::type_t, UNIT_TYPE>(first.value() * second); + return LLUnit::type_t>::type_t, UNITS>(first.value() * second); } -template -LLUnit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE> operator * (UNITLESS_TYPE first, LLUnit second) +template +LL_FORCE_INLINE LLUnit::type_t, STORAGE_TYPE>::type_t, UNITS> operator * (UNITLESS_TYPE first, LLUnit second) { - return LLUnit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE>(first * second.value()); + return LLUnit::type_t, STORAGE_TYPE>::type_t, UNITS>(first * second.value()); } -template -LLUnitImplicit operator * (LLUnitImplicit, LLUnitImplicit) +template +LLUnitImplicit operator * (LLUnitImplicit, LLUnitImplicit) { // spurious use of dependent type to stop gcc from triggering the static assertion before instantiating the template LL_BAD_TEMPLATE_INSTANTIATION(STORAGE_TYPE1, "multiplication of unit types results in new unit type - not supported."); - return LLUnitImplicit(); + return LLUnitImplicit(); } -template -LLUnitImplicit::type_t>::type_t, UNIT_TYPE> operator * (LLUnitImplicit first, UNITLESS_TYPE second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t>::type_t, UNITS> operator * (LLUnitImplicit first, UNITLESS_TYPE second) { - return LLUnitImplicit::type_t, UNIT_TYPE>(first.value() * second); + return LLUnitImplicit::type_t, UNITS>(first.value() * second); } -template -LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE> operator * (UNITLESS_TYPE first, LLUnitImplicit second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNITS> operator * (UNITLESS_TYPE first, LLUnitImplicit second) { - return LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNIT_TYPE>(first * second.value()); + return LLUnitImplicit::type_t, STORAGE_TYPE>::type_t, UNITS>(first * second.value()); } @@ -472,105 +596,42 @@ LLUnitImplicit -LLUnit::type_t>::type_t, UNIT_TYPE> operator / (LLUnit first, UNITLESS_TYPE second) +template +LL_FORCE_INLINE LLUnit::type_t>::type_t, UNITS> operator / (LLUnit first, UNITLESS_TYPE second) { - return LLUnit::type_t>::type_t, UNIT_TYPE>(first.value() / second); + return LLUnit::type_t>::type_t, UNITS>(first.value() / second); } -template -typename LLResultTypeDivide::type_t operator / (LLUnit first, LLUnit second) +template +LL_FORCE_INLINE typename LLResultTypeDivide::type_t operator / (LLUnit first, LLUnit second) { return first.value() / first.convert(second).value(); } -template -LLUnitImplicit::type_t>::type_t, UNIT_TYPE> operator / (LLUnitImplicit first, UNITLESS_TYPE second) +template +LL_FORCE_INLINE LLUnitImplicit::type_t>::type_t, UNITS> operator / (LLUnitImplicit first, UNITLESS_TYPE second) { - return LLUnitImplicit::type_t>::type_t, UNIT_TYPE>(first.value() / second); + return LLUnitImplicit::type_t>::type_t, UNITS>(first.value() / second); } -template -typename LLResultTypeDivide::type_t operator / (LLUnitImplicit first, LLUnitImplicit second) +template +LL_FORCE_INLINE typename LLResultTypeDivide::type_t operator / (LLUnitImplicit first, LLUnitImplicit second) { return (typename LLResultTypeDivide::type_t)(first.value() / first.convert(second).value()); } -template -typename LLResultTypeDivide::type_t operator / (LLUnit first, LLUnitImplicit second) +template +LL_FORCE_INLINE typename LLResultTypeDivide::type_t operator / (LLUnit first, LLUnitImplicit second) { return (typename LLResultTypeDivide::type_t)(first.value() / first.convert(second).value()); } -template -typename LLResultTypeDivide::type_t operator / (LLUnitImplicit first, LLUnit second) +template +LL_FORCE_INLINE typename LLResultTypeDivide::type_t operator / (LLUnitImplicit first, LLUnit second) { return (typename LLResultTypeDivide::type_t)(first.value() / first.convert(second).value()); } -// -// comparison operators -// - -#define LL_UNIT_DECLARE_COMPARISON_OPERATOR(op) \ -template \ -bool operator op (LLUnitImplicit first, LLUnitImplicit second) \ -{ \ - return first.value() op first.convert(second).value(); \ -} \ - \ -template \ -bool operator op (LLUnitImplicit first, UNITLESS_TYPE second) \ -{ \ - return first.value() op second; \ -} \ - \ -template \ -bool operator op (UNITLESS_TYPE first, LLUnitImplicit second) \ -{ \ - return first op second.value(); \ -} \ - \ -template \ -bool operator op (LLUnit first, LLUnit second) \ -{ \ - return first.value() op first.convert(second).value(); \ -} \ - \ -template \ -bool operator op (LLUnit first, UNITLESS_TYPE second) \ -{ \ - LL_BAD_TEMPLATE_INSTANTIATION(UNITLESS_TYPE, "operator " #op " requires compatible unit types"); \ - return false; \ -} \ - \ -template \ -bool operator op (UNITLESS_TYPE first, LLUnit second) \ -{ \ - LL_BAD_TEMPLATE_INSTANTIATION(UNITLESS_TYPE, "operator " #op " requires compatible unit types"); \ - return false; \ -} \ - \ -template \ -bool operator op (LLUnit first, LLUnitImplicit second) \ -{ \ - return first.value() op first.convert(second).value(); \ -} \ - \ -template \ -bool operator op (LLUnitImplicit first, LLUnit second) \ -{ \ - return first.value() op first.convert(second).value(); \ -} - -LL_UNIT_DECLARE_COMPARISON_OPERATOR(<); -LL_UNIT_DECLARE_COMPARISON_OPERATOR(<=); -LL_UNIT_DECLARE_COMPARISON_OPERATOR(>); -LL_UNIT_DECLARE_COMPARISON_OPERATOR(>=); -LL_UNIT_DECLARE_COMPARISON_OPERATOR(==); -LL_UNIT_DECLARE_COMPARISON_OPERATOR(!=); - - template struct LLGetUnitLabel { -- cgit v1.2.3 From 00bd492b30f0dcb49d354be74e6e9a312a84863f Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Tue, 27 Aug 2013 16:36:36 -0700 Subject: got linear unit conversions (like fahrenheit <-> celsius) working correctly further optimizations for codegen --- indra/llcommon/llunittype.h | 74 +++++++++++++++++++++++++-------------------- 1 file changed, 41 insertions(+), 33 deletions(-) (limited to 'indra/llcommon/llunittype.h') diff --git a/indra/llcommon/llunittype.h b/indra/llcommon/llunittype.h index a5e99070b6..50037ccade 100644 --- a/indra/llcommon/llunittype.h +++ b/indra/llcommon/llunittype.h @@ -147,35 +147,35 @@ struct LLUnit } template - LL_FORCE_INLINE bool operator == (LLUnit other) + LL_FORCE_INLINE bool operator == (LLUnit other) const { return mValue == convert(other).value(); } template - LL_FORCE_INLINE bool operator != (LLUnit other) + LL_FORCE_INLINE bool operator != (LLUnit other) const { return mValue != convert(other).value(); } template - LL_FORCE_INLINE bool operator < (LLUnit other) + LL_FORCE_INLINE bool operator < (LLUnit other) const { return mValue < convert(other).value(); } template - LL_FORCE_INLINE bool operator <= (LLUnit other) + LL_FORCE_INLINE bool operator <= (LLUnit other) const { return mValue <= convert(other).value(); } template - LL_FORCE_INLINE bool operator > (LLUnit other) + LL_FORCE_INLINE bool operator > (LLUnit other) const { return mValue > convert(other).value(); } template - LL_FORCE_INLINE bool operator >= (LLUnit other) + LL_FORCE_INLINE bool operator >= (LLUnit other) const { return mValue >= convert(other).value(); } @@ -193,6 +193,15 @@ struct LLUnit return result; } + template + LL_FORCE_INLINE static self_t convert(LLUnit v) + { + self_t result; + STORAGE_TYPE divisor = ll_convert_units(v, result); + result.mValue /= divisor; + return result; + } + template LL_FORCE_INLINE static self_t convert(LLUnit v) { @@ -276,78 +285,78 @@ struct LLUnitImplicit : public LLUnit using base_t::operator ==; template - LL_FORCE_INLINE bool operator == (LLUnitImplicit other) + LL_FORCE_INLINE bool operator == (LLUnitImplicit other) const { return mValue == convert(other).value(); } template - LL_FORCE_INLINE bool operator == (STORAGE_T other) + LL_FORCE_INLINE bool operator == (STORAGE_T other) const { return mValue == other; } using base_t::operator !=; template - LL_FORCE_INLINE bool operator != (LLUnitImplicit other) + LL_FORCE_INLINE bool operator != (LLUnitImplicit other) const { return mValue != convert(other).value(); } template - LL_FORCE_INLINE bool operator != (STORAGE_T other) + LL_FORCE_INLINE bool operator != (STORAGE_T other) const { return mValue != other; } using base_t::operator <; template - LL_FORCE_INLINE bool operator < (LLUnitImplicit other) + LL_FORCE_INLINE bool operator < (LLUnitImplicit other) const { return mValue < convert(other).value(); } template - LL_FORCE_INLINE bool operator < (STORAGE_T other) + LL_FORCE_INLINE bool operator < (STORAGE_T other) const { return mValue < other; } using base_t::operator <=; template - LL_FORCE_INLINE bool operator <= (LLUnitImplicit other) + LL_FORCE_INLINE bool operator <= (LLUnitImplicit other) const { return mValue <= convert(other).value(); } template - LL_FORCE_INLINE bool operator <= (STORAGE_T other) + LL_FORCE_INLINE bool operator <= (STORAGE_T other) const { return mValue <= other; } using base_t::operator >; template - LL_FORCE_INLINE bool operator > (LLUnitImplicit other) + LL_FORCE_INLINE bool operator > (LLUnitImplicit other) const { return mValue > convert(other).value(); } template - LL_FORCE_INLINE bool operator > (STORAGE_T other) + LL_FORCE_INLINE bool operator > (STORAGE_T other) const { return mValue > other; } using base_t::operator >=; template - LL_FORCE_INLINE bool operator >= (LLUnitImplicit other) + LL_FORCE_INLINE bool operator >= (LLUnitImplicit other) const { return mValue >= convert(other).value(); } template - LL_FORCE_INLINE bool operator >= (STORAGE_T other) + LL_FORCE_INLINE bool operator >= (STORAGE_T other) const { return mValue >= other; } @@ -670,16 +679,14 @@ struct LLUnitLinearOps template self_t operator + (OTHER_T other) { - mValue /= mDivisor; - mValue += other; + mValue += other * mDivisor; return *this; } template self_t operator - (OTHER_T other) { - mValue /= mDivisor; - mValue -= other; + mValue -= other * mDivisor; return *this; } @@ -694,7 +701,8 @@ struct LLUnitInverseLinearOps LLUnitInverseLinearOps(T val) : mValue(val), - mDivisor(1) + mDivisor(1), + mMultiplicand(1) {} template @@ -708,27 +716,27 @@ struct LLUnitInverseLinearOps self_t operator / (OTHER_T other) { mValue *= other; + mMultiplicand *= other; return *this; } template self_t operator + (OTHER_T other) { - mValue /= mDivisor; - mValue -= other; + mValue -= other * mMultiplicand; return *this; } template self_t operator - (OTHER_T other) { - mValue /= mDivisor; - mValue += other; + mValue += other * mMultiplicand; return *this; } T mValue; T mDivisor; + T mMultiplicand; }; #define LL_DECLARE_BASE_UNIT(base_unit_name, unit_label) \ @@ -762,20 +770,20 @@ template LL_FORCE_INLINE S2 ll_convert_units(LLUnit in, LLUnit& out) \ { \ typedef typename LLResultTypePromote::type_t result_storage_t; \ - LLUnitInverseLinearOps op = \ + LLUnitInverseLinearOps result = \ LLUnitInverseLinearOps(in.value()) conversion_operation; \ - out = LLUnit((S2)op.mValue); \ - return op.mDivisor; \ + out = LLUnit((S2)result.mValue); \ + return result.mDivisor; \ } \ \ template \ LL_FORCE_INLINE S2 ll_convert_units(LLUnit in, LLUnit& out) \ { \ typedef typename LLResultTypePromote::type_t result_storage_t; \ - LLUnitLinearOps op = \ + LLUnitLinearOps result = \ LLUnitLinearOps(in.value()) conversion_operation; \ - out = LLUnit((S2)op.mValue); \ - return op.mDivisor; \ + out = LLUnit((S2)result.mValue); \ + return result.mDivisor; \ } #define LL_DECLARE_UNIT_TYPEDEFS(ns, unit_name) \ -- cgit v1.2.3 From 35e8c81dd8afd05b6298a1849c63bc9238ab3271 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Tue, 27 Aug 2013 16:48:57 -0700 Subject: gcc build fix --- indra/llcommon/llunittype.h | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) (limited to 'indra/llcommon/llunittype.h') diff --git a/indra/llcommon/llunittype.h b/indra/llcommon/llunittype.h index 50037ccade..5cf41343fc 100644 --- a/indra/llcommon/llunittype.h +++ b/indra/llcommon/llunittype.h @@ -287,78 +287,78 @@ struct LLUnitImplicit : public LLUnit template LL_FORCE_INLINE bool operator == (LLUnitImplicit other) const { - return mValue == convert(other).value(); + return base_t::mValue == convert(other).value(); } template LL_FORCE_INLINE bool operator == (STORAGE_T other) const { - return mValue == other; + return base_t::mValue == other; } using base_t::operator !=; template LL_FORCE_INLINE bool operator != (LLUnitImplicit other) const { - return mValue != convert(other).value(); + return base_t::mValue != convert(other).value(); } template LL_FORCE_INLINE bool operator != (STORAGE_T other) const { - return mValue != other; + return base_t::mValue != other; } using base_t::operator <; template LL_FORCE_INLINE bool operator < (LLUnitImplicit other) const { - return mValue < convert(other).value(); + return base_t::mValue < convert(other).value(); } template LL_FORCE_INLINE bool operator < (STORAGE_T other) const { - return mValue < other; + return base_t::mValue < other; } using base_t::operator <=; template LL_FORCE_INLINE bool operator <= (LLUnitImplicit other) const { - return mValue <= convert(other).value(); + return base_t::mValue <= convert(other).value(); } template LL_FORCE_INLINE bool operator <= (STORAGE_T other) const { - return mValue <= other; + return base_t::mValue <= other; } using base_t::operator >; template LL_FORCE_INLINE bool operator > (LLUnitImplicit other) const { - return mValue > convert(other).value(); + return base_t::mValue > convert(other).value(); } template LL_FORCE_INLINE bool operator > (STORAGE_T other) const { - return mValue > other; + return base_t::mValue > other; } using base_t::operator >=; template LL_FORCE_INLINE bool operator >= (LLUnitImplicit other) const { - return mValue >= convert(other).value(); + return base_t::mValue >= convert(other).value(); } template LL_FORCE_INLINE bool operator >= (STORAGE_T other) const { - return mValue >= other; + return base_t::mValue >= other; } }; -- cgit v1.2.3 From 25e2fbe419655b2f8ce22dbafa1de6bc655b1567 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Tue, 27 Aug 2013 18:08:32 -0700 Subject: got comparisons between implicit and explicit units working right --- indra/llcommon/llunittype.h | 44 ++++++++++++++++++++++++++++++++++++++------ 1 file changed, 38 insertions(+), 6 deletions(-) (limited to 'indra/llcommon/llunittype.h') diff --git a/indra/llcommon/llunittype.h b/indra/llcommon/llunittype.h index 50037ccade..663641d6b1 100644 --- a/indra/llcommon/llunittype.h +++ b/indra/llcommon/llunittype.h @@ -169,11 +169,13 @@ struct LLUnit { return mValue <= convert(other).value(); } + template LL_FORCE_INLINE bool operator > (LLUnit other) const { return mValue > convert(other).value(); } + template LL_FORCE_INLINE bool operator >= (LLUnit other) const { @@ -283,7 +285,12 @@ struct LLUnitImplicit : public LLUnit base_t::mValue -= convert(other).value(); } - using base_t::operator ==; + template + LL_FORCE_INLINE bool operator == (LLUnit other) const + { + return mValue == convert(other).value(); + } + template LL_FORCE_INLINE bool operator == (LLUnitImplicit other) const { @@ -296,7 +303,12 @@ struct LLUnitImplicit : public LLUnit return mValue == other; } - using base_t::operator !=; + template + LL_FORCE_INLINE bool operator != (LLUnit other) const + { + return mValue != convert(other).value(); + } + template LL_FORCE_INLINE bool operator != (LLUnitImplicit other) const { @@ -309,7 +321,12 @@ struct LLUnitImplicit : public LLUnit return mValue != other; } - using base_t::operator <; + template + LL_FORCE_INLINE bool operator < (LLUnit other) const + { + return mValue < convert(other).value(); + } + template LL_FORCE_INLINE bool operator < (LLUnitImplicit other) const { @@ -322,7 +339,12 @@ struct LLUnitImplicit : public LLUnit return mValue < other; } - using base_t::operator <=; + template + LL_FORCE_INLINE bool operator <= (LLUnit other) const + { + return mValue <= convert(other).value(); + } + template LL_FORCE_INLINE bool operator <= (LLUnitImplicit other) const { @@ -335,7 +357,12 @@ struct LLUnitImplicit : public LLUnit return mValue <= other; } - using base_t::operator >; + template + LL_FORCE_INLINE bool operator > (LLUnit other) const + { + return mValue > convert(other).value(); + } + template LL_FORCE_INLINE bool operator > (LLUnitImplicit other) const { @@ -348,7 +375,12 @@ struct LLUnitImplicit : public LLUnit return mValue > other; } - using base_t::operator >=; + template + LL_FORCE_INLINE bool operator >= (LLUnit other) const + { + return mValue >= convert(other).value(); + } + template LL_FORCE_INLINE bool operator >= (LLUnitImplicit other) const { -- cgit v1.2.3 From 5a22ab52618ae588f1303c7b6d0bb7a8c4b4ca93 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Tue, 27 Aug 2013 18:10:41 -0700 Subject: more gcc fixes --- indra/llcommon/llunittype.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'indra/llcommon/llunittype.h') diff --git a/indra/llcommon/llunittype.h b/indra/llcommon/llunittype.h index fbb8eb2431..fb72d6d8a9 100644 --- a/indra/llcommon/llunittype.h +++ b/indra/llcommon/llunittype.h @@ -288,7 +288,7 @@ struct LLUnitImplicit : public LLUnit template LL_FORCE_INLINE bool operator == (LLUnit other) const { - return mValue == convert(other).value(); + return base_t::mValue == convert(other).value(); } template @@ -306,7 +306,7 @@ struct LLUnitImplicit : public LLUnit template LL_FORCE_INLINE bool operator != (LLUnit other) const { - return mValue != convert(other).value(); + return base_t::mValue != convert(other).value(); } template @@ -324,7 +324,7 @@ struct LLUnitImplicit : public LLUnit template LL_FORCE_INLINE bool operator < (LLUnit other) const { - return mValue < convert(other).value(); + return base_t::mValue < convert(other).value(); } template @@ -342,7 +342,7 @@ struct LLUnitImplicit : public LLUnit template LL_FORCE_INLINE bool operator <= (LLUnit other) const { - return mValue <= convert(other).value(); + return base_t::mValue <= convert(other).value(); } template @@ -360,7 +360,7 @@ struct LLUnitImplicit : public LLUnit template LL_FORCE_INLINE bool operator > (LLUnit other) const { - return mValue > convert(other).value(); + return base_t::mValue > convert(other).value(); } template @@ -378,7 +378,7 @@ struct LLUnitImplicit : public LLUnit template LL_FORCE_INLINE bool operator >= (LLUnit other) const { - return mValue >= convert(other).value(); + return base_t::mValue >= convert(other).value(); } template -- cgit v1.2.3 From 12f0f8cb72f789e21b01b45063dcc5f1f5292087 Mon Sep 17 00:00:00 2001 From: Richard Linden Date: Tue, 1 Oct 2013 13:46:43 -0700 Subject: changed over to manual naming of MemTrackable stats changed claimMem and disclaimMem behavior to not pass through argument added more mem tracking stats to floater_stats --- indra/llcommon/llunittype.h | 1 + 1 file changed, 1 insertion(+) (limited to 'indra/llcommon/llunittype.h') diff --git a/indra/llcommon/llunittype.h b/indra/llcommon/llunittype.h index fb72d6d8a9..0e05ecd683 100644 --- a/indra/llcommon/llunittype.h +++ b/indra/llcommon/llunittype.h @@ -80,6 +80,7 @@ struct LLUnit { typedef LLUnit self_t; typedef STORAGE_TYPE storage_t; + typedef void is_unit_t; // value initialization LL_FORCE_INLINE explicit LLUnit(storage_t value = storage_t()) -- cgit v1.2.3