From 9f7bfa1c3710856cd2b0a0a8a429d6c45b0fcd09 Mon Sep 17 00:00:00 2001
From: Richard Linden <none@none>
Date: Thu, 15 Aug 2013 00:02:23 -0700
Subject: moved unit types out of LLUnits namespace, since they are prefixed

---
 indra/llcommon/llfasttimer.cpp       |  10 +-
 indra/llcommon/llfasttimer.h         |   2 +-
 indra/llcommon/lltimer.cpp           |   2 +-
 indra/llcommon/lltraceaccumulators.h |   6 +-
 indra/llcommon/lltracerecording.cpp  |  62 +++----
 indra/llcommon/lltracerecording.h    |  36 ++--
 indra/llcommon/llunit.h              | 342 ++++++++++++++++++-----------------
 7 files changed, 236 insertions(+), 224 deletions(-)

(limited to 'indra/llcommon')

diff --git a/indra/llcommon/llfasttimer.cpp b/indra/llcommon/llfasttimer.cpp
index a91e716f19..5f92c66f47 100755
--- a/indra/llcommon/llfasttimer.cpp
+++ b/indra/llcommon/llfasttimer.cpp
@@ -339,7 +339,7 @@ void TimeBlock::logStats()
 		}
 		call_count++;
 
-		LLUnits::F64Seconds total_time(0);
+		F64Seconds total_time(0);
 		LLSD sd;
 
 		{
@@ -382,11 +382,11 @@ void TimeBlock::dumpCurTimes()
 		++it)
 	{
 		TimeBlock* timerp = (*it);
-		LLUnits::F64Seconds total_time = last_frame_recording.getSum(*timerp);
+		F64Seconds total_time = last_frame_recording.getSum(*timerp);
 		U32 num_calls = last_frame_recording.getSum(timerp->callCount());
 
 		// Don't bother with really brief times, keep output concise
-		if (total_time < LLUnits::F32Milliseconds(0.1f)) continue;
+		if (total_time < F32Milliseconds(0.1f)) continue;
 
 		std::ostringstream out_str;
 		TimeBlock* parent_timerp = timerp;
@@ -466,11 +466,11 @@ void TimeBlockAccumulator::reset( const TimeBlockAccumulator* other )
 	}
 }
 
-LLUnits::F64Seconds BlockTimer::getElapsedTime()
+F64Seconds BlockTimer::getElapsedTime()
 {
 	U64 total_time = TimeBlock::getCPUClockCount64() - mStartTime;
 
-	return LLUnits::F64Seconds((F64)total_time / (F64)TimeBlock::countsPerSecond());
+	return F64Seconds((F64)total_time / (F64)TimeBlock::countsPerSecond());
 }
 
 
diff --git a/indra/llcommon/llfasttimer.h b/indra/llcommon/llfasttimer.h
index 589b9bb941..ccf71c3f4c 100755
--- a/indra/llcommon/llfasttimer.h
+++ b/indra/llcommon/llfasttimer.h
@@ -48,7 +48,7 @@ public:
 	BlockTimer(TimeBlock& timer);
 	~BlockTimer();
 
-	LLUnits::F64Seconds getElapsedTime();
+	F64Seconds getElapsedTime();
 
 private:
 
diff --git a/indra/llcommon/lltimer.cpp b/indra/llcommon/lltimer.cpp
index 7077ea4b4f..74f3a7f587 100755
--- a/indra/llcommon/lltimer.cpp
+++ b/indra/llcommon/lltimer.cpp
@@ -262,7 +262,7 @@ LLUnitImplicit<U64, LLUnits::Microseconds> totalTime()
 	}
 
 	// Return the total clock tick count in microseconds.
-	return LLUnits::U64Microseconds(gTotalTimeClockCount*gClocksToMicroseconds);
+	return U64Microseconds(gTotalTimeClockCount*gClocksToMicroseconds);
 }
 
 
diff --git a/indra/llcommon/lltraceaccumulators.h b/indra/llcommon/lltraceaccumulators.h
index 4d79964526..73da6bd2d8 100644
--- a/indra/llcommon/lltraceaccumulators.h
+++ b/indra/llcommon/lltraceaccumulators.h
@@ -418,7 +418,7 @@ namespace LLTrace
 	class TimeBlockAccumulator
 	{
 	public:
-		typedef LLUnits::F64Seconds value_t;
+		typedef F64Seconds value_t;
 		typedef TimeBlockAccumulator self_t;
 
 		// fake classes that allows us to view different facets of underlying statistic
@@ -429,7 +429,7 @@ namespace LLTrace
 
 		struct SelfTimeFacet
 		{
-			typedef LLUnits::F64Seconds value_t;
+			typedef F64Seconds value_t;
 		};
 
 		TimeBlockAccumulator();
@@ -492,7 +492,7 @@ namespace LLTrace
 
 		struct ChildMemFacet
 		{
-			typedef LLUnit<F64, LLUnits::Bytes> value_t;
+			typedef F64Bytes value_t;
 		};
 
 		MemStatAccumulator()
diff --git a/indra/llcommon/lltracerecording.cpp b/indra/llcommon/lltracerecording.cpp
index 963f0cd174..bc98eebf31 100644
--- a/indra/llcommon/lltracerecording.cpp
+++ b/indra/llcommon/lltracerecording.cpp
@@ -95,7 +95,7 @@ void Recording::handleReset()
 {
 	mBuffers.write()->reset();
 
-	mElapsedSeconds = LLUnits::F64Seconds(0.0);
+	mElapsedSeconds = F64Seconds(0.0);
 	mSamplingTimer.reset();
 }
 
@@ -128,17 +128,17 @@ void Recording::appendRecording( Recording& other )
 	mElapsedSeconds += other.mElapsedSeconds;
 }
 
-LLUnits::F64Seconds Recording::getSum(const TraceType<TimeBlockAccumulator>& stat)
+F64Seconds Recording::getSum(const TraceType<TimeBlockAccumulator>& stat)
 {
 	const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
-	return LLUnits::F64Seconds((F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) 
+	return F64Seconds((F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) 
 				/ (F64)LLTrace::TimeBlock::countsPerSecond());
 }
 
-LLUnits::F64Seconds Recording::getSum(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat)
+F64Seconds Recording::getSum(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat)
 {
 	const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
-	return LLUnits::F64Seconds((F64)(accumulator.mSelfTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond());
+	return F64Seconds((F64)(accumulator.mSelfTimeCounter) / (F64)LLTrace::TimeBlock::countsPerSecond());
 }
 
 
@@ -147,19 +147,19 @@ U32 Recording::getSum(const TraceType<TimeBlockAccumulator::CallCountFacet>& sta
 	return mBuffers->mStackTimers[stat.getIndex()].mCalls;
 }
 
-LLUnits::F64Seconds Recording::getPerSec(const TraceType<TimeBlockAccumulator>& stat)
+F64Seconds Recording::getPerSec(const TraceType<TimeBlockAccumulator>& stat)
 {
 	const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
 
-	return LLUnits::F64Seconds((F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) 
+	return F64Seconds((F64)(accumulator.mTotalTimeCounter - accumulator.mStartTotalTimeCounter) 
 				/ ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds.value()));
 }
 
-LLUnits::F64Seconds Recording::getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat)
+F64Seconds Recording::getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat)
 {
 	const TimeBlockAccumulator& accumulator = mBuffers->mStackTimers[stat.getIndex()];
 
-	return LLUnits::F64Seconds((F64)(accumulator.mSelfTimeCounter) 
+	return F64Seconds((F64)(accumulator.mSelfTimeCounter) 
 			/ ((F64)LLTrace::TimeBlock::countsPerSecond() * mElapsedSeconds.value()));
 }
 
@@ -168,54 +168,54 @@ F32 Recording::getPerSec(const TraceType<TimeBlockAccumulator::CallCountFacet>&
 	return (F32)mBuffers->mStackTimers[stat.getIndex()].mCalls / mElapsedSeconds.value();
 }
 
-LLUnits::F64Bytes Recording::getMin(const TraceType<MemStatAccumulator>& stat)
+F64Bytes Recording::getMin(const TraceType<MemStatAccumulator>& stat)
 {
-	return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMin());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMin());
 }
 
-LLUnits::F64Bytes Recording::getMean(const TraceType<MemStatAccumulator>& stat)
+F64Bytes Recording::getMean(const TraceType<MemStatAccumulator>& stat)
 {
-	return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMean());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMean());
 }
 
-LLUnits::F64Bytes Recording::getMax(const TraceType<MemStatAccumulator>& stat)
+F64Bytes Recording::getMax(const TraceType<MemStatAccumulator>& stat)
 {
-	return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMax());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getMax());
 }
 
-LLUnits::F64Bytes Recording::getStandardDeviation(const TraceType<MemStatAccumulator>& stat)
+F64Bytes Recording::getStandardDeviation(const TraceType<MemStatAccumulator>& stat)
 {
-	return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getStandardDeviation());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getStandardDeviation());
 }
 
-LLUnits::F64Bytes Recording::getLastValue(const TraceType<MemStatAccumulator>& stat)
+F64Bytes Recording::getLastValue(const TraceType<MemStatAccumulator>& stat)
 {
-	return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getLastValue());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mSize.getLastValue());
 }
 
-LLUnits::F64Bytes Recording::getMin(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
+F64Bytes Recording::getMin(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
 {
-	return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMin());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMin());
 }
 
-LLUnits::F64Bytes Recording::getMean(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
+F64Bytes Recording::getMean(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
 {
-	return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMean());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMean());
 }
 
-LLUnits::F64Bytes Recording::getMax(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
+F64Bytes Recording::getMax(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
 {
-	return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMax());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getMax());
 }
 
-LLUnits::F64Bytes Recording::getStandardDeviation(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
+F64Bytes Recording::getStandardDeviation(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
 {
-	return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getStandardDeviation());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getStandardDeviation());
 }
 
-LLUnits::F64Bytes Recording::getLastValue(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
+F64Bytes Recording::getLastValue(const TraceType<MemStatAccumulator::ChildMemFacet>& stat)
 {
-	return LLUnits::F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getLastValue());
+	return F64Bytes(mBuffers->mMemStats[stat.getIndex()].mChildSize.getLastValue());
 }
 
 U32 Recording::getSum(const TraceType<MemStatAccumulator::AllocationCountFacet>& stat)
@@ -427,9 +427,9 @@ void PeriodicRecording::appendPeriodicRecording( PeriodicRecording& other )
 	getCurRecording().setPlayState(getPlayState());
 }
 
-LLUnits::F64Seconds PeriodicRecording::getDuration() const
+F64Seconds PeriodicRecording::getDuration() const
 {
-	LLUnits::F64Seconds duration;
+	F64Seconds duration;
 	size_t num_periods = mRecordingPeriods.size();
 	for (size_t i = 1; i <= num_periods; i++)
 	{
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index 3c23c6a3f6..68b95a1003 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -166,26 +166,26 @@ namespace LLTrace
 		void makeUnique() { mBuffers.makeUnique(); }
 
 		// Timer accessors
-		LLUnits::F64Seconds getSum(const TraceType<TimeBlockAccumulator>& stat);
-		LLUnits::F64Seconds getSum(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat);
+		F64Seconds getSum(const TraceType<TimeBlockAccumulator>& stat);
+		F64Seconds getSum(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat);
 		U32 getSum(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat);
 
-		LLUnits::F64Seconds getPerSec(const TraceType<TimeBlockAccumulator>& stat);
-		LLUnits::F64Seconds getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat);
+		F64Seconds getPerSec(const TraceType<TimeBlockAccumulator>& stat);
+		F64Seconds getPerSec(const TraceType<TimeBlockAccumulator::SelfTimeFacet>& stat);
 		F32 getPerSec(const TraceType<TimeBlockAccumulator::CallCountFacet>& stat);
 
 		// Memory accessors
-		LLUnit<F64, LLUnits::Bytes> getMin(const TraceType<MemStatAccumulator>& stat);
-		LLUnit<F64, LLUnits::Bytes> getMean(const TraceType<MemStatAccumulator>& stat);
-		LLUnit<F64, LLUnits::Bytes> getMax(const TraceType<MemStatAccumulator>& stat);
-		LLUnit<F64, LLUnits::Bytes> getStandardDeviation(const TraceType<MemStatAccumulator>& stat);
-		LLUnit<F64, LLUnits::Bytes> getLastValue(const TraceType<MemStatAccumulator>& stat);
-
-		LLUnit<F64, LLUnits::Bytes> getMin(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
-		LLUnit<F64, LLUnits::Bytes> getMean(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
-		LLUnit<F64, LLUnits::Bytes> getMax(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
-		LLUnit<F64, LLUnits::Bytes> getStandardDeviation(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
-		LLUnit<F64, LLUnits::Bytes> getLastValue(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+		F64Bytes getMin(const TraceType<MemStatAccumulator>& stat);
+		F64Bytes getMean(const TraceType<MemStatAccumulator>& stat);
+		F64Bytes getMax(const TraceType<MemStatAccumulator>& stat);
+		F64Bytes getStandardDeviation(const TraceType<MemStatAccumulator>& stat);
+		F64Bytes getLastValue(const TraceType<MemStatAccumulator>& stat);
+
+		F64Bytes getMin(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+		F64Bytes getMean(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+		F64Bytes getMax(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+		F64Bytes getStandardDeviation(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
+		F64Bytes getLastValue(const TraceType<MemStatAccumulator::ChildMemFacet>& stat);
 
 		U32 getSum(const TraceType<MemStatAccumulator::AllocationCountFacet>& stat);
 		U32 getSum(const TraceType<MemStatAccumulator::DeallocationCountFacet>& stat);
@@ -295,7 +295,7 @@ namespace LLTrace
 
 		U32 getSampleCount(const TraceType<EventAccumulator>& stat);
 
-		LLUnits::F64Seconds getDuration() const { return mElapsedSeconds; }
+		F64Seconds getDuration() const { return mElapsedSeconds; }
 
 	protected:
 		friend class ThreadRecorder;
@@ -310,7 +310,7 @@ namespace LLTrace
 		class ThreadRecorder* getThreadRecorder(); 
 
 		LLTimer											mSamplingTimer;
-		LLUnits::F64Seconds					mElapsedSeconds;
+		F64Seconds					mElapsedSeconds;
 		LLCopyOnWritePointer<AccumulatorBufferGroup>	mBuffers;
 		bool											mInHandOff;
 
@@ -325,7 +325,7 @@ namespace LLTrace
 		void nextPeriod();
 		size_t getNumRecordedPeriods() { return mNumPeriods; }
 
-		LLUnits::F64Seconds getDuration() const;
+		F64Seconds getDuration() const;
 
 		void appendPeriodicRecording(PeriodicRecording& other);
 		void appendRecording(Recording& recording);
diff --git a/indra/llcommon/llunit.h b/indra/llcommon/llunit.h
index 9a367d9182..b62bebc440 100644
--- a/indra/llcommon/llunit.h
+++ b/indra/llcommon/llunit.h
@@ -643,55 +643,58 @@ LL_DECLARE_DERIVED_UNIT(Megabytes, * 1000,		Gigabytes, "GB");
 LL_DECLARE_DERIVED_UNIT(Bytes, * 1024,			Kibibytes, "KiB");
 LL_DECLARE_DERIVED_UNIT(Kibibytes, * 1024,		Mibibytes, "MiB");
 LL_DECLARE_DERIVED_UNIT(Mibibytes, * 1024,		Gibibytes, "GiB");
+}
 
-typedef LLUnit<F32, Bytes>     F32Bytes;
-typedef LLUnit<F32, Kilobytes> F32KiloBytes;
-typedef LLUnit<F32, Megabytes> F32MegaBytes;
-typedef LLUnit<F32, Gigabytes> F32GigaBytes;
-typedef LLUnit<F32, Kibibytes> F32KibiBytes;
-typedef LLUnit<F32, Mibibytes> F32MibiBytes;
-typedef LLUnit<F32, Gibibytes> F32GibiBytes;
-
-typedef LLUnit<F64, Bytes>     F64Bytes;
-typedef LLUnit<F64, Kilobytes> F64KiloBytes;
-typedef LLUnit<F64, Megabytes> F64MegaBytes;
-typedef LLUnit<F64, Gigabytes> F64GigaBytes;
-typedef LLUnit<F64, Kibibytes> F64KibiBytes;
-typedef LLUnit<F64, Mibibytes> F64MibiBytes;
-typedef LLUnit<F64, Gibibytes> F64GibiBytes;
-
-typedef LLUnit<S32, Bytes>     S32Bytes;
-typedef LLUnit<S32, Kilobytes> S32KiloBytes;
-typedef LLUnit<S32, Megabytes> S32MegaBytes;
-typedef LLUnit<S32, Gigabytes> S32GigaBytes;
-typedef LLUnit<S32, Kibibytes> S32KibiBytes;
-typedef LLUnit<S32, Mibibytes> S32MibiBytes;
-typedef LLUnit<S32, Gibibytes> S32GibiBytes;
-
-typedef LLUnit<U32, Bytes>     U32Bytes;
-typedef LLUnit<U32, Kilobytes> U32KiloBytes;
-typedef LLUnit<U32, Megabytes> U32MegaBytes;
-typedef LLUnit<U32, Gigabytes> U32GigaBytes;
-typedef LLUnit<U32, Kibibytes> U32KibiBytes;
-typedef LLUnit<U32, Mibibytes> U32MibiBytes;
-typedef LLUnit<U32, Gibibytes> U32GibiBytes;
-
-typedef LLUnit<S64, Bytes>     S64Bytes;
-typedef LLUnit<S64, Kilobytes> S64KiloBytes;
-typedef LLUnit<S64, Megabytes> S64MegaBytes;
-typedef LLUnit<S64, Gigabytes> S64GigaBytes;
-typedef LLUnit<S64, Kibibytes> S64KibiBytes;
-typedef LLUnit<S64, Mibibytes> S64MibiBytes;
-typedef LLUnit<S64, Gibibytes> S64GibiBytes;
-
-typedef LLUnit<U64, Bytes>     U64Bytes;
-typedef LLUnit<U64, Kilobytes> U64KiloBytes;
-typedef LLUnit<U64, Megabytes> U64MegaBytes;
-typedef LLUnit<U64, Gigabytes> U64GigaBytes;
-typedef LLUnit<U64, Kibibytes> U64KibiBytes;
-typedef LLUnit<U64, Mibibytes> U64MibiBytes;
-typedef LLUnit<U64, Gibibytes> U64GibiBytes;
+typedef LLUnit<F32, LLUnits::Bytes>     F32Bytes;
+typedef LLUnit<F32, LLUnits::Kilobytes> F32Kilobytes;
+typedef LLUnit<F32, LLUnits::Megabytes> F32Megabytes;
+typedef LLUnit<F32, LLUnits::Gigabytes> F32Gigabytes;
+typedef LLUnit<F32, LLUnits::Kibibytes> F32Kibibytes;
+typedef LLUnit<F32, LLUnits::Mibibytes> F32Mibibytes;
+typedef LLUnit<F32, LLUnits::Gibibytes> F32Gibibytes;
+
+typedef LLUnit<F64, LLUnits::Bytes>     F64Bytes;
+typedef LLUnit<F64, LLUnits::Kilobytes> F64Kilobytes;
+typedef LLUnit<F64, LLUnits::Megabytes> F64Megabytes;
+typedef LLUnit<F64, LLUnits::Gigabytes> F64Gigabytes;
+typedef LLUnit<F64, LLUnits::Kibibytes> F64Kibibytes;
+typedef LLUnit<F64, LLUnits::Mibibytes> F64Mibibytes;
+typedef LLUnit<F64, LLUnits::Gibibytes> F64Gibibytes;
+
+typedef LLUnit<S32, LLUnits::Bytes>     S32Bytes;
+typedef LLUnit<S32, LLUnits::Kilobytes> S32Kilobytes;
+typedef LLUnit<S32, LLUnits::Megabytes> S32Megabytes;
+typedef LLUnit<S32, LLUnits::Gigabytes> S32Gigabytes;
+typedef LLUnit<S32, LLUnits::Kibibytes> S32Kibibytes;
+typedef LLUnit<S32, LLUnits::Mibibytes> S32Mibibytes;
+typedef LLUnit<S32, LLUnits::Gibibytes> S32Gibibytes;
+
+typedef LLUnit<U32, LLUnits::Bytes>     U32Bytes;
+typedef LLUnit<U32, LLUnits::Kilobytes> U32Kilobytes;
+typedef LLUnit<U32, LLUnits::Megabytes> U32Megabytes;
+typedef LLUnit<U32, LLUnits::Gigabytes> U32Gigabytes;
+typedef LLUnit<U32, LLUnits::Kibibytes> U32Kibibytes;
+typedef LLUnit<U32, LLUnits::Mibibytes> U32Mibibytes;
+typedef LLUnit<U32, LLUnits::Gibibytes> U32Gibibytes;
+
+typedef LLUnit<S64, LLUnits::Bytes>     S64Bytes;
+typedef LLUnit<S64, LLUnits::Kilobytes> S64Kilobytes;
+typedef LLUnit<S64, LLUnits::Megabytes> S64Megabytes;
+typedef LLUnit<S64, LLUnits::Gigabytes> S64Gigabytes;
+typedef LLUnit<S64, LLUnits::Kibibytes> S64Kibibytes;
+typedef LLUnit<S64, LLUnits::Mibibytes> S64Mibibytes;
+typedef LLUnit<S64, LLUnits::Gibibytes> S64Gibibytes;
+
+typedef LLUnit<U64, LLUnits::Bytes>     U64Bytes;
+typedef LLUnit<U64, LLUnits::Kilobytes> U64Kilobytes;
+typedef LLUnit<U64, LLUnits::Megabytes> U64Megabytes;
+typedef LLUnit<U64, LLUnits::Gigabytes> U64Gigabytes;
+typedef LLUnit<U64, LLUnits::Kibibytes> U64Kibibytes;
+typedef LLUnit<U64, LLUnits::Mibibytes> U64Mibibytes;
+typedef LLUnit<U64, LLUnits::Gibibytes> U64Gibibytes;
 
+namespace LLUnits
+{
 LL_DECLARE_DERIVED_UNIT(Bytes, / 8,				Bits, "b");
 LL_DECLARE_DERIVED_UNIT(Bits, * 1000,			Kilobits, "Kb");
 LL_DECLARE_DERIVED_UNIT(Kilobits, * 1000,		Megabits, "Mb");
@@ -699,55 +702,58 @@ LL_DECLARE_DERIVED_UNIT(Megabits, * 1000,		Gigabits, "Gb");
 LL_DECLARE_DERIVED_UNIT(Bits, * 1024,			Kibibits, "Kib");
 LL_DECLARE_DERIVED_UNIT(Kibibits, * 1024,		Mibibits, "Mib");  
 LL_DECLARE_DERIVED_UNIT(Mibibits, * 1024,		Gibibits, "Gib");
+}
 
-typedef LLUnit<F32, Bits>     F32Bits;
-typedef LLUnit<F32, Kilobits> F32KiloBits;
-typedef LLUnit<F32, Megabits> F32MegaBits;
-typedef LLUnit<F32, Gigabits> F32GigaBits;
-typedef LLUnit<F32, Kibibits> F32KibiBits;
-typedef LLUnit<F32, Mibibits> F32MibiBits;
-typedef LLUnit<F32, Gibibits> F32GibiBits;
-
-typedef LLUnit<F64, Bits>     F64Bits;
-typedef LLUnit<F64, Kilobits> F64KiloBits;
-typedef LLUnit<F64, Megabits> F64MegaBits;
-typedef LLUnit<F64, Gigabits> F64GigaBits;
-typedef LLUnit<F64, Kibibits> F64KibiBits;
-typedef LLUnit<F64, Mibibits> F64MibiBits;
-typedef LLUnit<F64, Gibibits> F64GibiBits;
-
-typedef LLUnit<S32, Bits>     S32Bits;
-typedef LLUnit<S32, Kilobits> S32KiloBits;
-typedef LLUnit<S32, Megabits> S32MegaBits;
-typedef LLUnit<S32, Gigabits> S32GigaBits;
-typedef LLUnit<S32, Kibibits> S32KibiBits;
-typedef LLUnit<S32, Mibibits> S32MibiBits;
-typedef LLUnit<S32, Gibibits> S32GibiBits;
-
-typedef LLUnit<U32, Bits>     U32Bits;
-typedef LLUnit<U32, Kilobits> U32KiloBits;
-typedef LLUnit<U32, Megabits> U32MegaBits;
-typedef LLUnit<U32, Gigabits> U32GigaBits;
-typedef LLUnit<U32, Kibibits> U32KibiBits;
-typedef LLUnit<U32, Mibibits> U32MibiBits;
-typedef LLUnit<U32, Gibibits> U32GibiBits;
-
-typedef LLUnit<S64, Bits>     S64Bits;
-typedef LLUnit<S64, Kilobits> S64KiloBits;
-typedef LLUnit<S64, Megabits> S64MegaBits;
-typedef LLUnit<S64, Gigabits> S64GigaBits;
-typedef LLUnit<S64, Kibibits> S64KibiBits;
-typedef LLUnit<S64, Mibibits> S64MibiBits;
-typedef LLUnit<S64, Gibibits> S64GibiBits;
-
-typedef LLUnit<U64, Bits>     U64Bits;
-typedef LLUnit<U64, Kilobits> U64KiloBits;
-typedef LLUnit<U64, Megabits> U64MegaBits;
-typedef LLUnit<U64, Gigabits> U64GigaBits;
-typedef LLUnit<U64, Kibibits> U64KibiBits;
-typedef LLUnit<U64, Mibibits> U64MibiBits;
-typedef LLUnit<U64, Gibibits> U64GibiBits;
+typedef LLUnit<F32, LLUnits::Bits>     F32Bits;
+typedef LLUnit<F32, LLUnits::Kilobits> F32Kilobits;
+typedef LLUnit<F32, LLUnits::Megabits> F32Megabits;
+typedef LLUnit<F32, LLUnits::Gigabits> F32Gigabits;
+typedef LLUnit<F32, LLUnits::Kibibits> F32Kibibits;
+typedef LLUnit<F32, LLUnits::Mibibits> F32Mibibits;
+typedef LLUnit<F32, LLUnits::Gibibits> F32Gibibits;
+					
+typedef LLUnit<F64, LLUnits::Bits>     F64Bits;
+typedef LLUnit<F64, LLUnits::Kilobits> F64Kilobits;
+typedef LLUnit<F64, LLUnits::Megabits> F64Megabits;
+typedef LLUnit<F64, LLUnits::Gigabits> F64Gigabits;
+typedef LLUnit<F64, LLUnits::Kibibits> F64Kibibits;
+typedef LLUnit<F64, LLUnits::Mibibits> F64Mibibits;
+typedef LLUnit<F64, LLUnits::Gibibits> F64Gibibits;
+
+typedef LLUnit<S32, LLUnits::Bits>     S32Bits;
+typedef LLUnit<S32, LLUnits::Kilobits> S32Kilobits;
+typedef LLUnit<S32, LLUnits::Megabits> S32Megabits;
+typedef LLUnit<S32, LLUnits::Gigabits> S32Gigabits;
+typedef LLUnit<S32, LLUnits::Kibibits> S32Kibibits;
+typedef LLUnit<S32, LLUnits::Mibibits> S32Mibibits;
+typedef LLUnit<S32, LLUnits::Gibibits> S32Gibibits;
+
+typedef LLUnit<U32, LLUnits::Bits>     U32Bits;
+typedef LLUnit<U32, LLUnits::Kilobits> U32Kilobits;
+typedef LLUnit<U32, LLUnits::Megabits> U32Megabits;
+typedef LLUnit<U32, LLUnits::Gigabits> U32Gigabits;
+typedef LLUnit<U32, LLUnits::Kibibits> U32Kibibits;
+typedef LLUnit<U32, LLUnits::Mibibits> U32Mibibits;
+typedef LLUnit<U32, LLUnits::Gibibits> U32Gibibits;
+
+typedef LLUnit<S64, LLUnits::Bits>     S64Bits;
+typedef LLUnit<S64, LLUnits::Kilobits> S64Kilobits;
+typedef LLUnit<S64, LLUnits::Megabits> S64Megabits;
+typedef LLUnit<S64, LLUnits::Gigabits> S64Gigabits;
+typedef LLUnit<S64, LLUnits::Kibibits> S64Kibibits;
+typedef LLUnit<S64, LLUnits::Mibibits> S64Mibibits;
+typedef LLUnit<S64, LLUnits::Gibibits> S64Gibibits;
+
+typedef LLUnit<U64, LLUnits::Bits>     U64Bits;
+typedef LLUnit<U64, LLUnits::Kilobits> U64Kilobits;
+typedef LLUnit<U64, LLUnits::Megabits> U64Megabits;
+typedef LLUnit<U64, LLUnits::Gigabits> U64Gigabits;
+typedef LLUnit<U64, LLUnits::Kibibits> U64Kibibits;
+typedef LLUnit<U64, LLUnits::Mibibits> U64Mibibits;
+typedef LLUnit<U64, LLUnits::Gibibits> U64Gibibits;
 
+namespace LLUnits
+{
 LL_DECLARE_BASE_UNIT(Seconds, "s");
 LL_DECLARE_DERIVED_UNIT(Seconds, * 60,			Minutes, "min");
 LL_DECLARE_DERIVED_UNIT(Minutes, * 60,			Hours, "h");
@@ -755,90 +761,96 @@ LL_DECLARE_DERIVED_UNIT(Hours, * 24,			Days, "d");
 LL_DECLARE_DERIVED_UNIT(Seconds, / 1000,		Milliseconds, "ms");
 LL_DECLARE_DERIVED_UNIT(Milliseconds, / 1000,	Microseconds, "\x09\x3cs");
 LL_DECLARE_DERIVED_UNIT(Microseconds, / 1000,	Nanoseconds, "ns");
+}
 
-typedef LLUnit<F32, Seconds>      F32Seconds;
-typedef LLUnit<F32, Minutes>      F32Minutes;
-typedef LLUnit<F32, Hours>        F32Hours;
-typedef LLUnit<F32, Days>         F32Days;
-typedef LLUnit<F32, Milliseconds> F32Milliseconds;
-typedef LLUnit<F32, Microseconds> F32Microseconds;
-typedef LLUnit<F32, Nanoseconds>  F32Nanoseconds;
-
-typedef LLUnit<F64, Seconds>      F64Seconds;
-typedef LLUnit<F64, Minutes>      F64Minutes;
-typedef LLUnit<F64, Hours>        F64Hours;
-typedef LLUnit<F64, Days>         F64Days;
-typedef LLUnit<F64, Milliseconds> F64Milliseconds;
-typedef LLUnit<F64, Microseconds> F64Microseconds;
-typedef LLUnit<F64, Nanoseconds>  F64Nanoseconds;
-
-typedef LLUnit<S32, Seconds>      S32Seconds;
-typedef LLUnit<S32, Minutes>      S32Minutes;
-typedef LLUnit<S32, Hours>        S32Hours;
-typedef LLUnit<S32, Days>         S32Days;
-typedef LLUnit<S32, Milliseconds> S32Milliseconds;
-typedef LLUnit<S32, Microseconds> S32Microseconds;
-typedef LLUnit<S32, Nanoseconds>  S32Nanoseconds;
-
-typedef LLUnit<U32, Seconds>      U32Seconds;
-typedef LLUnit<U32, Minutes>      U32Minutes;
-typedef LLUnit<U32, Hours>        U32Hours;
-typedef LLUnit<U32, Days>         U32Days;
-typedef LLUnit<U32, Milliseconds> U32Milliseconds;
-typedef LLUnit<U32, Microseconds> U32Microseconds;
-typedef LLUnit<U32, Nanoseconds>  U32Nanoseconds;
-
-typedef LLUnit<S64, Seconds>      S64Seconds;
-typedef LLUnit<S64, Minutes>      S64Minutes;
-typedef LLUnit<S64, Hours>        S64Hours;
-typedef LLUnit<S64, Days>         S64Days;
-typedef LLUnit<S64, Milliseconds> S64Milliseconds;
-typedef LLUnit<S64, Microseconds> S64Microseconds;
-typedef LLUnit<S64, Nanoseconds>  S64Nanoseconds;
-
-typedef LLUnit<U64, Seconds>      U64Seconds;
-typedef LLUnit<U64, Minutes>      U64Minutes;
-typedef LLUnit<U64, Hours>        U64Hours;
-typedef LLUnit<U64, Days>         U64Days;
-typedef LLUnit<U64, Milliseconds> U64Milliseconds;
-typedef LLUnit<U64, Microseconds> U64Microseconds;
-typedef LLUnit<U64, Nanoseconds>  U64Nanoseconds;
+typedef LLUnit<F32, LLUnits::Seconds>      F32Seconds;
+typedef LLUnit<F32, LLUnits::Minutes>      F32Minutes;
+typedef LLUnit<F32, LLUnits::Hours>        F32Hours;
+typedef LLUnit<F32, LLUnits::Days>         F32Days;
+typedef LLUnit<F32, LLUnits::Milliseconds> F32Milliseconds;
+typedef LLUnit<F32, LLUnits::Microseconds> F32Microseconds;
+typedef LLUnit<F32, LLUnits::Nanoseconds>  F32Nanoseconds;
+
+typedef LLUnit<F64, LLUnits::Seconds>      F64Seconds;
+typedef LLUnit<F64, LLUnits::Minutes>      F64Minutes;
+typedef LLUnit<F64, LLUnits::Hours>        F64Hours;
+typedef LLUnit<F64, LLUnits::Days>         F64Days;
+typedef LLUnit<F64, LLUnits::Milliseconds> F64Milliseconds;
+typedef LLUnit<F64, LLUnits::Microseconds> F64Microseconds;
+typedef LLUnit<F64, LLUnits::Nanoseconds>  F64Nanoseconds;
+
+typedef LLUnit<S32, LLUnits::Seconds>      S32Seconds;
+typedef LLUnit<S32, LLUnits::Minutes>      S32Minutes;
+typedef LLUnit<S32, LLUnits::Hours>        S32Hours;
+typedef LLUnit<S32, LLUnits::Days>         S32Days;
+typedef LLUnit<S32, LLUnits::Milliseconds> S32Milliseconds;
+typedef LLUnit<S32, LLUnits::Microseconds> S32Microseconds;
+typedef LLUnit<S32, LLUnits::Nanoseconds>  S32Nanoseconds;
+
+typedef LLUnit<U32, LLUnits::Seconds>      U32Seconds;
+typedef LLUnit<U32, LLUnits::Minutes>      U32Minutes;
+typedef LLUnit<U32, LLUnits::Hours>        U32Hours;
+typedef LLUnit<U32, LLUnits::Days>         U32Days;
+typedef LLUnit<U32, LLUnits::Milliseconds> U32Milliseconds;
+typedef LLUnit<U32, LLUnits::Microseconds> U32Microseconds;
+typedef LLUnit<U32, LLUnits::Nanoseconds>  U32Nanoseconds;
+
+typedef LLUnit<S64, LLUnits::Seconds>      S64Seconds;
+typedef LLUnit<S64, LLUnits::Minutes>      S64Minutes;
+typedef LLUnit<S64, LLUnits::Hours>        S64Hours;
+typedef LLUnit<S64, LLUnits::Days>         S64Days;
+typedef LLUnit<S64, LLUnits::Milliseconds> S64Milliseconds;
+typedef LLUnit<S64, LLUnits::Microseconds> S64Microseconds;
+typedef LLUnit<S64, LLUnits::Nanoseconds>  S64Nanoseconds;
+					
+typedef LLUnit<U64, LLUnits::Seconds>      U64Seconds;
+typedef LLUnit<U64, LLUnits::Minutes>      U64Minutes;
+typedef LLUnit<U64, LLUnits::Hours>        U64Hours;
+typedef LLUnit<U64, LLUnits::Days>         U64Days;
+typedef LLUnit<U64, LLUnits::Milliseconds> U64Milliseconds;
+typedef LLUnit<U64, LLUnits::Microseconds> U64Microseconds;
+typedef LLUnit<U64, LLUnits::Nanoseconds>  U64Nanoseconds;
 
+namespace LLUnits
+{
 LL_DECLARE_BASE_UNIT(Meters, "m");
 LL_DECLARE_DERIVED_UNIT(Meters, * 1000,			Kilometers, "km");
 LL_DECLARE_DERIVED_UNIT(Meters, / 100,			Centimeters, "cm");
 LL_DECLARE_DERIVED_UNIT(Meters, / 1000,			Millimeters, "mm");
+}
 
-typedef LLUnit<F32, Meters>      F32Meters;
-typedef LLUnit<F32, Kilometers>  F32Kilometers;
-typedef LLUnit<F32, Centimeters> F32Centimeters;
-typedef LLUnit<F32, Millimeters> F32Millimeters;
+typedef LLUnit<F32, LLUnits::Meters>      F32Meters;
+typedef LLUnit<F32, LLUnits::Kilometers>  F32Kilometers;
+typedef LLUnit<F32, LLUnits::Centimeters> F32Centimeters;
+typedef LLUnit<F32, LLUnits::Millimeters> F32Millimeters;
 
-typedef LLUnit<F64, Meters>      F64Meters;
-typedef LLUnit<F64, Kilometers>  F64Kilometers;
-typedef LLUnit<F64, Centimeters> F64Centimeters;
-typedef LLUnit<F64, Millimeters> F64Millimeters;
+typedef LLUnit<F64, LLUnits::Meters>      F64Meters;
+typedef LLUnit<F64, LLUnits::Kilometers>  F64Kilometers;
+typedef LLUnit<F64, LLUnits::Centimeters> F64Centimeters;
+typedef LLUnit<F64, LLUnits::Millimeters> F64Millimeters;
 
-typedef LLUnit<S32, Meters>      S32Meters;
-typedef LLUnit<S32, Kilometers>  S32Kilometers;
-typedef LLUnit<S32, Centimeters> S32Centimeters;
-typedef LLUnit<S32, Millimeters> S32Millimeters;
+typedef LLUnit<S32, LLUnits::Meters>      S32Meters;
+typedef LLUnit<S32, LLUnits::Kilometers>  S32Kilometers;
+typedef LLUnit<S32, LLUnits::Centimeters> S32Centimeters;
+typedef LLUnit<S32, LLUnits::Millimeters> S32Millimeters;
 
-typedef LLUnit<U32, Meters>      U32Meters;
-typedef LLUnit<U32, Kilometers>  U32Kilometers;
-typedef LLUnit<U32, Centimeters> U32Centimeters;
-typedef LLUnit<U32, Millimeters> U32Millimeters;
+typedef LLUnit<U32, LLUnits::Meters>      U32Meters;
+typedef LLUnit<U32, LLUnits::Kilometers>  U32Kilometers;
+typedef LLUnit<U32, LLUnits::Centimeters> U32Centimeters;
+typedef LLUnit<U32, LLUnits::Millimeters> U32Millimeters;
 
-typedef LLUnit<S64, Meters>      S64Meters;
-typedef LLUnit<S64, Kilometers>  S64Kilometers;
-typedef LLUnit<S64, Centimeters> S64Centimeters;
-typedef LLUnit<S64, Millimeters> S64Millimeters;
+typedef LLUnit<S64, LLUnits::Meters>      S64Meters;
+typedef LLUnit<S64, LLUnits::Kilometers>  S64Kilometers;
+typedef LLUnit<S64, LLUnits::Centimeters> S64Centimeters;
+typedef LLUnit<S64, LLUnits::Millimeters> S64Millimeters;
 
-typedef LLUnit<U64, Meters>      U64Meters;
-typedef LLUnit<U64, Kilometers>  U64Kilometers;
-typedef LLUnit<U64, Centimeters> U64Centimeters;
-typedef LLUnit<U64, Millimeters> U64Millimeters;
+typedef LLUnit<U64, LLUnits::Meters>      U64Meters;
+typedef LLUnit<U64, LLUnits::Kilometers>  U64Kilometers;
+typedef LLUnit<U64, LLUnits::Centimeters> U64Centimeters;
+typedef LLUnit<U64, LLUnits::Millimeters> U64Millimeters;
 
+namespace LLUnits
+{
 // rare units
 LL_DECLARE_BASE_UNIT(Hertz, "Hz");
 LL_DECLARE_DERIVED_UNIT(Hertz, * 1000,			Kilohertz, "KHz");
-- 
cgit v1.2.3