activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r702265 - in /activemq/activemq-cpp/trunk/src: main/decaf/util/concurrent/TimeUnit.cpp main/decaf/util/concurrent/TimeUnit.h test/decaf/util/concurrent/TimeUnitTest.cpp test/decaf/util/concurrent/TimeUnitTest.h
Date Mon, 06 Oct 2008 21:12:39 GMT
Author: tabish
Date: Mon Oct  6 14:12:39 2008
New Revision: 702265

URL: http://svn.apache.org/viewvc?rev=702265&view=rev
Log:
Adding Start of the TimeUnit class.

Modified:
    activemq/activemq-cpp/trunk/src/main/decaf/util/concurrent/TimeUnit.cpp
    activemq/activemq-cpp/trunk/src/main/decaf/util/concurrent/TimeUnit.h
    activemq/activemq-cpp/trunk/src/test/decaf/util/concurrent/TimeUnitTest.cpp
    activemq/activemq-cpp/trunk/src/test/decaf/util/concurrent/TimeUnitTest.h

Modified: activemq/activemq-cpp/trunk/src/main/decaf/util/concurrent/TimeUnit.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/main/decaf/util/concurrent/TimeUnit.cpp?rev=702265&r1=702264&r2=702265&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/src/main/decaf/util/concurrent/TimeUnit.cpp (original)
+++ activemq/activemq-cpp/trunk/src/main/decaf/util/concurrent/TimeUnit.cpp Mon Oct  6 14:12:39
2008
@@ -46,21 +46,6 @@
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// Lookup table to check saturation.  Note that because we are
-// dividing these down, we don't have to deal with asymmetry of
-// MIN/MAX values.
-//
-const long long TimeUnit::overflows[] = {
-    0, // unused
-    Long::MAX_VALUE / 1000LL,
-    Long::MAX_VALUE / ( 1000LL * 1000LL ),
-    Long::MAX_VALUE / ( 1000LL * 1000LL * 1000LL ),
-    Long::MAX_VALUE / ( 1000LL * 1000LL * 1000LL * 60LL ),
-    Long::MAX_VALUE / ( 1000LL * 1000LL * 1000LL * 60LL * 60LL ),
-    Long::MAX_VALUE / ( 1000LL * 1000LL * 1000LL * 60LL * 60LL * 24LL )
-};
-
-////////////////////////////////////////////////////////////////////////////////
 TimeUnit::TimeUnit( int index, const std::string& name ) {
     this->index = index;
     this->name = name;
@@ -68,23 +53,104 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 long long TimeUnit::convert( long long sourceDuration, const TimeUnit& sourceUnit ) const
{
-    return this->doConvert( sourceUnit.index - this->index, sourceDuration );
+    return this->doConvert( sourceUnit.index, this->index, sourceDuration );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-long long TimeUnit::doConvert( long long delta, long long duration ) const {
+long long TimeUnit::doConvert( int srcIndex, int destIndex, long long duration ) const {
 
-    if( delta == 0 ) {
+    if( duration == 0 ) {
         return duration;
-    } else if( delta < 0 ) {
-        return duration / multipliers[-delta];
-    } else if( duration > overflows[delta] ) {
-        return Long::MAX_VALUE;
-    } else if( duration < -overflows[delta] ) {
-        return Long::MIN_VALUE;
+    } else if( srcIndex > destIndex ) {
+        return scale( duration,
+                      multipliers[srcIndex] / multipliers[destIndex],
+                      Long::MAX_VALUE / ( multipliers[srcIndex] / multipliers[destIndex]
) );
+    } else if( srcIndex < destIndex ) {
+        return duration / ( multipliers[destIndex] / multipliers[srcIndex] );
     }
 
-    return duration * multipliers[delta];
+    // Same unit, no conversion.
+    return duration;
+
+    /*
+    NANOSECONDS {
+        public long toNanos(long d)   { return d; }
+        public long toMicros(long d)  { return d/(C1/C0); }
+        public long toMillis(long d)  { return d/(C2/C0); }
+        public long toSeconds(long d) { return d/(C3/C0); }
+        public long toMinutes(long d) { return d/(C4/C0); }
+        public long toHours(long d)   { return d/(C5/C0); }
+        public long toDays(long d)    { return d/(C6/C0); }
+        public long convert(long d, TimeUnit u) { return u.toNanos(d); }
+        int excessNanos(long d, long m) { return (int)(d - (m*C2)); }
+    },
+    MICROSECONDS {
+        public long toNanos(long d)   { return x(d, C1/C0, MAX/(C1/C0)); }
+        public long toMicros(long d)  { return d; }
+        public long toMillis(long d)  { return d/(C2/C1); }
+        public long toSeconds(long d) { return d/(C3/C1); }
+        public long toMinutes(long d) { return d/(C4/C1); }
+        public long toHours(long d)   { return d/(C5/C1); }
+        public long toDays(long d)    { return d/(C6/C1); }
+        public long convert(long d, TimeUnit u) { return u.toMicros(d); }
+        int excessNanos(long d, long m) { return (int)((d*C1) - (m*C2)); }
+    },
+    MILLISECONDS {
+        public long toNanos(long d)   { return x(d, C2/C0, MAX/(C2/C0)); }
+        public long toMicros(long d)  { return x(d, C2/C1, MAX/(C2/C1)); }
+        public long toMillis(long d)  { return d; }
+        public long toSeconds(long d) { return d/(C3/C2); }
+        public long toMinutes(long d) { return d/(C4/C2); }
+        public long toHours(long d)   { return d/(C5/C2); }
+        public long toDays(long d)    { return d/(C6/C2); }
+        public long convert(long d, TimeUnit u) { return u.toMillis(d); }
+        int excessNanos(long d, long m) { return 0; }
+    },
+    SECONDS {
+        public long toNanos(long d)   { return x(d, C3/C0, MAX/(C3/C0)); }
+        public long toMicros(long d)  { return x(d, C3/C1, MAX/(C3/C1)); }
+        public long toMillis(long d)  { return x(d, C3/C2, MAX/(C3/C2)); }
+        public long toSeconds(long d) { return d; }
+        public long toMinutes(long d) { return d/(C4/C3); }
+        public long toHours(long d)   { return d/(C5/C3); }
+        public long toDays(long d)    { return d/(C6/C3); }
+        public long convert(long d, TimeUnit u) { return u.toSeconds(d); }
+        int excessNanos(long d, long m) { return 0; }
+    },
+    MINUTES {
+        public long toNanos(long d)   { return x(d, C4/C0, MAX/(C4/C0)); }
+        public long toMicros(long d)  { return x(d, C4/C1, MAX/(C4/C1)); }
+        public long toMillis(long d)  { return x(d, C4/C2, MAX/(C4/C2)); }
+        public long toSeconds(long d) { return x(d, C4/C3, MAX/(C4/C3)); }
+        public long toMinutes(long d) { return d; }
+        public long toHours(long d)   { return d/(C5/C4); }
+        public long toDays(long d)    { return d/(C6/C4); }
+        public long convert(long d, TimeUnit u) { return u.toMinutes(d); }
+        int excessNanos(long d, long m) { return 0; }
+    },
+    HOURS {
+        public long toNanos(long d)   { return x(d, C5/C0, MAX/(C5/C0)); }
+        public long toMicros(long d)  { return x(d, C5/C1, MAX/(C5/C1)); }
+        public long toMillis(long d)  { return x(d, C5/C2, MAX/(C5/C2)); }
+        public long toSeconds(long d) { return x(d, C5/C3, MAX/(C5/C3)); }
+        public long toMinutes(long d) { return x(d, C5/C4, MAX/(C5/C4)); }
+        public long toHours(long d)   { return d; }
+        public long toDays(long d)    { return d/(C6/C5); }
+        public long convert(long d, TimeUnit u) { return u.toHours(d); }
+        int excessNanos(long d, long m) { return 0; }
+    },
+    DAYS {
+        public long toNanos(long d)   { return x(d, C6/C0, MAX/(C6/C0)); }
+        public long toMicros(long d)  { return x(d, C6/C1, MAX/(C6/C1)); }
+        public long toMillis(long d)  { return x(d, C6/C2, MAX/(C6/C2)); }
+        public long toSeconds(long d) { return x(d, C6/C3, MAX/(C6/C3)); }
+        public long toMinutes(long d) { return x(d, C6/C4, MAX/(C6/C4)); }
+        public long toHours(long d)   { return x(d, C6/C5, MAX/(C6/C5)); }
+        public long toDays(long d)    { return d; }
+        public long convert(long d, TimeUnit u) { return u.toDays(d); }
+        int excessNanos(long d, long m) { return 0; }
+    };
+    */
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -145,3 +211,14 @@
 bool TimeUnit::operator<( const TimeUnit& value ) const {
     return this->compareTo( value ) == -1;
 }
+
+////////////////////////////////////////////////////////////////////////////////
+long long TimeUnit::scale( long long duration, long long multiplier, long long overflow )
{
+    if( duration > overflow ) {
+        return Long::MAX_VALUE;
+    } else if( duration < -overflow ) {
+        return Long::MIN_VALUE;
+    }
+
+    return duration * multiplier;
+}

Modified: activemq/activemq-cpp/trunk/src/main/decaf/util/concurrent/TimeUnit.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/main/decaf/util/concurrent/TimeUnit.h?rev=702265&r1=702264&r2=702265&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/src/main/decaf/util/concurrent/TimeUnit.h (original)
+++ activemq/activemq-cpp/trunk/src/main/decaf/util/concurrent/TimeUnit.h Mon Oct  6 14:12:39
2008
@@ -61,23 +61,12 @@
         /** Array of Time Unit multipliers */
         static const long long multipliers[];
 
-        /**
-         * Lookup table to check saturation.  Note that because we are
-         * dividing these down, we don't have to deal with asymmetry of
-         * MIN/MAX values.
-         */
-        static const long long overflows[];
-
-        /**
-         * Name of the Unit being represented.
-         */
+        /** Name of the Unit being represented. */
         std::string name;
 
     public:
 
-        /**
-         * The Actual TimeUnit enumerations
-         */
+        /** The Actual TimeUnit enumerations */
         static const TimeUnit NANOSECONDS;
         static const TimeUnit MICROSECONDS;
         static const TimeUnit MILLISECONDS;
@@ -125,7 +114,7 @@
          * @see #convert
          */
         long long toNanos( long long duration ) const {
-            return doConvert( index, duration );
+            return doConvert( this->index, NANOSECONDS.index, duration );
         }
 
         /**
@@ -137,7 +126,7 @@
          * @see #convert
          */
         long long toMicros( long long duration ) const {
-            return doConvert( index - MICROSECONDS.index, duration );
+            return doConvert( this->index, MICROSECONDS.index, duration );
         }
 
         /**
@@ -149,7 +138,7 @@
          * @see #convert
          */
         long long toMillis( long long duration ) const {
-            return doConvert( index - MILLISECONDS.index, duration );
+            return doConvert( this->index, MILLISECONDS.index, duration );
         }
 
         /**
@@ -159,7 +148,37 @@
          * @see #convert
          */
         long long toSeconds( long long duration ) const {
-            return doConvert( index - SECONDS.index, duration );
+            return doConvert( this->index, SECONDS.index, duration );
+        }
+
+        /**
+         * Equivalent to <tt>MINUTES.convert(duration, this)</tt>.
+         * @param duration the duration
+         * @return the converted duration.
+         * @see #convert
+         */
+        long long toMinutes( long long duration ) const {
+            return doConvert( this->index, MINUTES.index, duration );
+        }
+
+        /**
+         * Equivalent to <tt>HOURS.convert(duration, this)</tt>.
+         * @param duration the duration
+         * @return the converted duration.
+         * @see #convert
+         */
+        long long toHours( long long duration ) const {
+            return doConvert( this->index, HOURS.index, duration );
+        }
+
+        /**
+         * Equivalent to <tt>DAYS.convert(duration, this)</tt>.
+         * @param duration the duration
+         * @return the converted duration.
+         * @see #convert
+         */
+        long long toDays( long long duration ) const {
+            return doConvert( this->index, DAYS.index, duration );
         }
 
         /**
@@ -274,7 +293,7 @@
     private:
 
         /* Perform the actual conversion */
-        long long doConvert( long long delta, long long duration ) const;
+        long long doConvert( int srcIndex, int destIndex, long long duration ) const;
 
         /*
          * Utility method to compute the excess-nanosecond argument to
@@ -282,6 +301,14 @@
          */
         int excessNanos( long long time, long long ms ) const;
 
+        /**
+         * Scale d by m, checking for overflow.
+         * @param duration - The amount of time to scale by the multiplier.
+         * @param multiplier - The scaling factor.
+         * @param overflow - The value at which d * m would cause an overflow.
+         */
+        static long long scale( long long duration, long long multiplier, long long overflow
);
+
     };
 
 }}}

Modified: activemq/activemq-cpp/trunk/src/test/decaf/util/concurrent/TimeUnitTest.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/test/decaf/util/concurrent/TimeUnitTest.cpp?rev=702265&r1=702264&r2=702265&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/src/test/decaf/util/concurrent/TimeUnitTest.cpp (original)
+++ activemq/activemq-cpp/trunk/src/test/decaf/util/concurrent/TimeUnitTest.cpp Mon Oct  6
14:12:39 2008
@@ -29,10 +29,9 @@
 using namespace decaf::util::concurrent;
 
 ////////////////////////////////////////////////////////////////////////////////
-void TimeUnitTest::testConvert() {
+void TimeUnitTest::testConvert1() {
 
     for( long long t = 0; t < 10; ++t ) {
-
         CPPUNIT_ASSERT( t == TimeUnit::SECONDS.convert( t, TimeUnit::SECONDS ) );
         CPPUNIT_ASSERT( t == TimeUnit::SECONDS.convert( 1000 * t, TimeUnit::MILLISECONDS
) );
         CPPUNIT_ASSERT( t == TimeUnit::SECONDS.convert( 1000000 * t, TimeUnit::MICROSECONDS
) );
@@ -53,10 +52,23 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+void TimeUnitTest::testConvert2() {
+
+    for( long long t = 0; t < 10; ++t ) {
+        CPPUNIT_ASSERT( t == TimeUnit::DAYS.convert( t * 24, TimeUnit::HOURS ) );
+        CPPUNIT_ASSERT( t == TimeUnit::HOURS.convert( t * 60, TimeUnit::MINUTES ) );
+        CPPUNIT_ASSERT( t == TimeUnit::MINUTES.convert( t * 60, TimeUnit::SECONDS ) );
+        CPPUNIT_ASSERT( t == TimeUnit::SECONDS.convert( t * 1000, TimeUnit::MILLISECONDS
) );
+        CPPUNIT_ASSERT( t == TimeUnit::MILLISECONDS.convert( t * 1000, TimeUnit::MICROSECONDS
) );
+        CPPUNIT_ASSERT( t == TimeUnit::MICROSECONDS.convert( t * 1000, TimeUnit::NANOSECONDS
) );
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
 void TimeUnitTest::testToNanos() {
+
     for( long long t = 0; t < 10; ++t ) {
         CPPUNIT_ASSERT( 1000000000 * t == TimeUnit::SECONDS.toNanos( t ) );
-
         CPPUNIT_ASSERT( 1000000 * t == TimeUnit::MILLISECONDS.toNanos( t ) );
         CPPUNIT_ASSERT( 1000 * t == TimeUnit::MICROSECONDS.toNanos( t ) );
         CPPUNIT_ASSERT( t == TimeUnit::NANOSECONDS.toNanos( t ) );
@@ -76,8 +88,8 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 void TimeUnitTest::testToMillis() {
-    for( long long t = 0; t < 10; ++t ) {
 
+    for( long long t = 0; t < 10; ++t ) {
         CPPUNIT_ASSERT( 1000 * t == TimeUnit::SECONDS.toMillis( t ) );
         CPPUNIT_ASSERT( t == TimeUnit::MILLISECONDS.toMillis( t ) );
         CPPUNIT_ASSERT( t == TimeUnit::MICROSECONDS.toMillis( t * 1000 ) );
@@ -87,8 +99,8 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 void TimeUnitTest::testToSeconds() {
-    for( long long t = 0; t < 10; ++t ) {
 
+    for( long long t = 0; t < 10; ++t ) {
         CPPUNIT_ASSERT( t == TimeUnit::SECONDS.toSeconds( t ) );
         CPPUNIT_ASSERT( t == TimeUnit::MILLISECONDS.toSeconds( t * 1000 ) );
         CPPUNIT_ASSERT( t == TimeUnit::MICROSECONDS.toSeconds( t * 1000000 ) );
@@ -97,6 +109,45 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+void TimeUnitTest::testToMinutes() {
+
+    for( long long t = 0; t < 10; ++t ) {
+        CPPUNIT_ASSERT( t == TimeUnit::MINUTES.toMinutes( t ) );
+        CPPUNIT_ASSERT( t == TimeUnit::SECONDS.toMinutes( t * 60 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::MILLISECONDS.toMinutes( t * 1000LL * 60 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::MICROSECONDS.toMinutes( t * 1000000LL * 60 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::NANOSECONDS.toMinutes( t * 1000000000LL * 60 ) );
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void TimeUnitTest::testToHours() {
+
+    for( long long t = 0; t < 10; ++t ) {
+        CPPUNIT_ASSERT( t == TimeUnit::HOURS.toHours( t ) );
+        CPPUNIT_ASSERT( t == TimeUnit::MINUTES.toHours( t * 60 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::SECONDS.toHours( t * 60 * 60 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::MILLISECONDS.toHours( t * 1000LL * 60 * 60 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::MICROSECONDS.toHours( t * 1000000LL * 60 * 60 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::NANOSECONDS.toHours( t * 1000000000LL * 60 * 60 )
);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void TimeUnitTest::testToDays() {
+
+    for( long long t = 0; t < 10; ++t ) {
+        CPPUNIT_ASSERT( t == TimeUnit::DAYS.toDays( t ) );
+        CPPUNIT_ASSERT( t == TimeUnit::HOURS.toDays( t * 24 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::MINUTES.toDays( t * 60 * 24 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::SECONDS.toDays( t * 60 * 60 * 24 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::MILLISECONDS.toDays( t * 1000LL * 60 * 60 * 24 ) );
+        CPPUNIT_ASSERT( t == TimeUnit::MICROSECONDS.toDays( t * 1000000LL * 60 * 60 * 24
) );
+        CPPUNIT_ASSERT( t == TimeUnit::NANOSECONDS.toDays( t * 1000000000LL * 60 * 60 * 24
) );
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
 void TimeUnitTest::testConvertSaturate() {
     CPPUNIT_ASSERT( Long::MAX_VALUE ==
         TimeUnit::NANOSECONDS.convert( Long::MAX_VALUE / 2, TimeUnit::SECONDS ) );
@@ -115,7 +166,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 void TimeUnitTest::testToString() {
     std::string s = TimeUnit::SECONDS.toString();
-    CPPUNIT_ASSERT( s.find_first_of( "ECOND" ) >= (std::size_t)0 );
+    CPPUNIT_ASSERT( s.find_first_of( "ECOND" ) != (std::size_t)0 );
 }
 
 //////////////////////////////////////////////////////////////////////////////////

Modified: activemq/activemq-cpp/trunk/src/test/decaf/util/concurrent/TimeUnitTest.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/test/decaf/util/concurrent/TimeUnitTest.h?rev=702265&r1=702264&r2=702265&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/src/test/decaf/util/concurrent/TimeUnitTest.h (original)
+++ activemq/activemq-cpp/trunk/src/test/decaf/util/concurrent/TimeUnitTest.h Mon Oct  6 14:12:39
2008
@@ -28,7 +28,8 @@
     class TimeUnitTest : public CppUnit::TestFixture {
 
         CPPUNIT_TEST_SUITE( TimeUnitTest );
-        CPPUNIT_TEST( testConvert );
+        CPPUNIT_TEST( testConvert1 );
+        CPPUNIT_TEST( testConvert2 );
         CPPUNIT_TEST( testToNanos );
         CPPUNIT_TEST( testToMicros );
         CPPUNIT_TEST( testToMillis );
@@ -38,6 +39,9 @@
         CPPUNIT_TEST( testToString );
         CPPUNIT_TEST( testTimedWait );
         CPPUNIT_TEST( testSleep );
+        CPPUNIT_TEST( testToMinutes );
+        CPPUNIT_TEST( testToHours );
+        CPPUNIT_TEST( testToDays );
         CPPUNIT_TEST_SUITE_END();
 
     public:
@@ -45,11 +49,15 @@
         TimeUnitTest() {}
         virtual ~TimeUnitTest() {}
 
-        void testConvert();
+        void testConvert1();
+        void testConvert2();
         void testToNanos();
         void testToMicros();
         void testToMillis();
         void testToSeconds();
+        void testToMinutes();
+        void testToHours();
+        void testToDays();
         void testConvertSaturate();
         void testToNanosSaturate();
         void testToString();



Mime
View raw message