zoolib

Revision: 2599
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2599&view=rev
Author:   agreen
Date:     2011-10-30 02:56:11 +0000 (Sun, 30 Oct 2011)
Log Message:
-----------
Comment.

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZCog.h

Modified: trunk/zoolib/source/cxx/zoolib/ZCog.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCog.h	2011-10-30 02:55:40 UTC (rev 2598)
+++ trunk/zoolib/source/cxx/zoolib/ZCog.h	2011-10-30 02:56:11 UTC (rev 2599)
@@ -99,6 +99,8 @@
 #pragma mark -
 #pragma mark * sCog function and pseudo operator
 
+#if 0
+
 const struct
 	{
 	template <class Param>
@@ -133,6 +135,8 @@
 
 	} sCog = {};
 
+#endif
+
 // =================================================================================================
 #pragma mark -
 #pragma mark * sCog_Term
@@ -616,7 +620,7 @@
 #pragma mark -
 #pragma mark * sCog_WhileUnchanged
 
-// Call second cog so long as the calling the first cog is unchanged.
+// Call cog1 so long as cog0 is unchanged.
 
 template <class Param>
 ZCog<Param> spCogFun_WhileUnchanged(const ZCog<Param>& iSelf, Param iParam,

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2598
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2598&view=rev
Author:   agreen
Date:     2011-10-30 02:55:40 +0000 (Sun, 30 Oct 2011)
Log Message:
-----------
Add operator-

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZMatrix.h

Modified: trunk/zoolib/source/cxx/zoolib/ZMatrix.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZMatrix.h	2011-10-29 15:19:22 UTC (rev 2597)
+++ trunk/zoolib/source/cxx/zoolib/ZMatrix.h	2011-10-30 02:55:40 UTC (rev 2598)
@@ -559,6 +559,22 @@
 
 // =================================================================================================
 #pragma mark -
+#pragma mark * Negate
+
+template <class E, size_t R, size_t C>
+ZMatrix<E,R,C> operator-(const ZMatrix<E,R,C>& iMat)
+	{
+	ZMatrix<E,R,C> result(null);
+	for (size_t c = 0; c < C; ++c)
+		{
+		for (size_t r = 0; r < R; ++r)
+			result.fE[c][r] = -iMat.fE[c][r];
+		}
+	return result;
+	}
+
+// =================================================================================================
+#pragma mark -
 #pragma mark * Scalar multiplication
 
 template <class E, size_t R, size_t C, class T>

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2584
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2584&view=rev
Author:   agreen
Date:     2011-10-21 20:25:48 +0000 (Fri, 21 Oct 2011)
Log Message:
-----------
Revise ZTween protocol so that it returns a ZQ<Val>, and is
not expected to return a usable value outside of zero-->duration.

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZTween.h
    trunk/zoolib/source/cxx/zoolib/ZTween_Std.h

Modified: trunk/zoolib/source/cxx/zoolib/ZTween.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZTween.h	2011-10-21 02:50:27 UTC (rev 2583)
+++ trunk/zoolib/source/cxx/zoolib/ZTween.h	2011-10-21 20:25:48 UTC (rev 2584)
@@ -26,17 +26,18 @@
 #include "zoolib/ZCompat_algorithm.h" // for std::binary_function
 #include "zoolib/ZCompat_cmath.h" // for fmod
 #include "zoolib/ZDebug.h" // for fmod
+#include "zoolib/ZQ.h"
 #include "zoolib/ZRef.h"
 
 namespace ZooLib {
 
 template <class Val0, class Val1>
-Val0 sCombineTweenVals(const Val0& iVal0, const Val1& iVal1);
+ZQ<Val0> sCombineTweenVals(const ZQ<Val0>& iVal0Q, const ZQ<Val1>& iVal1Q);
 
 template <class Val0, class Val1>
-struct TweenCombiner : public std::binary_function<Val0, Val1, Val0>
+struct TweenCombiner : public std::binary_function<ZQ<Val0>, ZQ<Val1>, ZQ<Val0> >
 	{
-	Val0 operator()(const Val0& i0, const Val1& i1) const
+	ZQ<Val0> operator()(const ZQ<Val0>& i0, const ZQ<Val1>& i1) const
 		{ return sCombineTweenVals<Val0,Val1>(i0, i1); }
 	};
 
@@ -63,26 +64,23 @@
 	virtual ~ZTween() {}
 
 // Our protocol
-	Val ValAt(bool iWrap, double iTime)
+	Val ValAtWrapped(double iTime)
 		{
-		if (iWrap)
+		const double duration = this->Duration();
+		if (duration <= 0)
 			{
-			const double duration = this->Duration();
-			if (duration <= 0)
-				{
-				iTime = 0;
-				}
-			else
-				{
-				iTime = fmod(iTime, duration);
-				if (iTime < 0)
-					iTime += duration;
-				}
+			iTime = 0;
 			}
-		return this->ValAt(iTime);
+		else
+			{
+			iTime = fmod(iTime, duration);
+			if (iTime < 0)
+				iTime += duration;
+			}
+		return this->QValAt(iTime).Get();
 		}
 
-	virtual Val ValAt(double iTime) = 0;
+	virtual ZQ<Val> QValAt(double iTime) = 0;
 	virtual double Duration() = 0;
 	};
 
@@ -109,8 +107,8 @@
 		{}
 
 // From ZTween
-	virtual Val0 ValAt(double iTime)
-		{ return fCombiner(f0->ValAt(iTime), f1->ValAt(iTime)); }
+	virtual ZQ<Val0> QValAt(double iTime)
+		{ return fCombiner(f0->QValAt(iTime), f1->QValAt(iTime)); }
 
 	virtual double Duration()
 		{ return std::max(sGetDuration(f0, fD0), sGetDuration(f1, fD1)); }
@@ -192,8 +190,8 @@
 		{}
 
 // From ZTween
-	virtual Val0 ValAt(double iTime)
-		{ return fCombiner(f0->ValAt(iTime), f1->ValAt(iTime)); }
+	virtual ZQ<Val0> QValAt(double iTime)
+		{ return fCombiner(f0->QValAt(iTime), f1->QValAt(iTime)); }
 
 	virtual double Duration()
 		{ return std::min(sGetDuration(f0, fD0), sGetDuration(f1, fD1)); }
@@ -252,14 +250,12 @@
 		{}
 
 // From ZTween
-	virtual Val ValAt(double iTime)
+	virtual ZQ<Val> QValAt(double iTime)
 		{
-		if (iTime <= 0)
-			return f0->ValAt(iTime);
-		else if (iTime < sGetDuration(f0, fD0))
-			return f0->ValAt(iTime);
+		if (iTime < sGetDuration(f0, fD0))
+			return f0->QValAt(iTime);
 		else
-			return f1->ValAt(iTime - sGetDuration(f0, fD0));
+			return f1->QValAt(iTime - sGetDuration(f0, fD0));
 		}
 
 	virtual double Duration()
@@ -313,10 +309,10 @@
 		{}
 
 // From ZTween
-	virtual Val0 ValAt(double iTime)
+	virtual ZQ<Val0> QValAt(double iTime)
 		{
 		const double time1 = iTime / sGetDuration(f0, fD0) * sGetDuration(f1, fD1);
-		return fCombiner(f0->ValAt(iTime), f1->ValAt(time1));
+		return fCombiner(f0->QValAt(iTime), f1->QValAt(time1));
 		}
 
 	virtual double Duration()
@@ -380,11 +376,11 @@
 		{}
 
 // From ZTween
-	virtual Val ValAt(double iTime)
+	virtual ZQ<Val> QValAt(double iTime)
 		{
 		const double childDuration = sGetDuration(fTween, fTweenDuration);
 		iTime = sMinMax(0.0, iTime, childDuration * fCount);
-		return fTween->ValAt(fmod(iTime, childDuration));
+		return fTween->QValAt(fmod(iTime, childDuration));
 		}
 
 	virtual double Duration()
@@ -419,10 +415,11 @@
 		{}
 
 // From ZTween
-	virtual Val ValAt(double iTime)
+	virtual ZQ<Val> QValAt(double iTime)
 		{
-		const double theTime = sMinMax(0.0, iTime, fDuration);
-		return fTween->ValAt(fmod(theTime, sGetDuration(fTween, fTweenDuration)));
+		if (iTime < 0 || iTime > fDuration)
+			return null;
+		return fTween->QValAt(fmod(iTime, sGetDuration(fTween, fTweenDuration)));
 		}
 
 	virtual double Duration()
@@ -457,8 +454,12 @@
 		{}
 
 // From ZTween
-	virtual Val ValAt(double iTime)
-		{ return fTween->ValAt(iTime); }
+	virtual ZQ<Val> QValAt(double iTime)
+		{
+		if (iTime > fDuration)
+			return null;
+		return fTween->QValAt(iTime);
+		}
 
 	virtual double Duration()
 		{ return fDuration; }
@@ -491,8 +492,12 @@
 		{}
 
 // From ZTween
-	virtual Val ValAt(double iTime)
-		{ return fTween->ValAt(iTime); }
+	virtual ZQ<Val> QValAt(double iTime)
+		{
+		if (iTime > this->Duration())
+			return null;
+		return fTween->QValAt(iTime);
+		}
 
 	virtual double Duration()
 		{ return std::min(fAtMost, sGetDuration(fTween, fTweenDuration)); }
@@ -526,8 +531,12 @@
 		{}
 
 // From ZTween
-	virtual Val ValAt(double iTime)
-		{ return fTween->ValAt(iTime); }
+	virtual ZQ<Val> QValAt(double iTime)
+		{
+		if (iTime > fAtLeast)
+			return null;
+		return fTween->QValAt(std::min(iTime, sGetDuration(fTween, fTweenDuration)));
+		}
 
 	virtual double Duration()
 		{ return std::max(fAtLeast, sGetDuration(fTween, fTweenDuration)); }
@@ -561,8 +570,8 @@
 		{}
 
 // From ZTween
-	virtual Val ValAt(double iTime)
-		{ return fTween->ValAt(iTime - fDelay); }
+	virtual ZQ<Val> QValAt(double iTime)
+		{ return fTween->QValAt(iTime - fDelay); }
 
 	virtual double Duration()
 		{ return std::max(0.0, sGetDuration(fTween, fTweenDuration) + fDelay); }
@@ -596,12 +605,12 @@
 		{ ZAssert(fRate); }
 
 // From ZTween
-	virtual Val ValAt(double iTime)
+	virtual ZQ<Val> QValAt(double iTime)
 		{
 		if (fRate > 0)
-			return fTween->ValAt(iTime / fRate);
+			return fTween->QValAt(iTime / fRate);
 		else
-			return fTween->ValAt(sGetDuration(fTween, fTweenDuration) + iTime/fRate);
+			return fTween->QValAt(sGetDuration(fTween, fTweenDuration) + iTime/fRate);
 		}
 
 	virtual double Duration()
@@ -640,8 +649,8 @@
 		{}
 
 // From ZTween
-	virtual Val ValAt(double iTime)
-		{ return fTween->ValAt(iTime / sGetDuration(fTween, fTweenDuration)); }
+	virtual ZQ<Val> QValAt(double iTime)
+		{ return fTween->QValAt(iTime / sGetDuration(fTween, fTweenDuration)); }
 
 	virtual double Duration()
 		{ return 1; }
@@ -674,8 +683,12 @@
 		{}
 
 // From ZTween
-	virtual Val ValAt(double iTime)
-		{ return fVal; }
+	virtual ZQ<Val> QValAt(double iTime)
+		{
+		if (iTime < 0 || iTime > fDuration)
+			return null;
+		return fVal;
+		}
 
 	virtual double Duration()
 		{ return fDuration; }
@@ -716,8 +729,12 @@
 		{}
 
 // From ZTween
-	virtual Val ValAt(double iTime)
-		{ return fOffset + fTween->ValAt(iTime); }
+	virtual ZQ<Val> QValAt(double iTime)
+		{
+		if (ZQ<Val> theQ = fTween->QValAt(iTime))
+			return *theQ + fOffset;
+		return null;
+		}
 
 	virtual double Duration()
 		{ return sGetDuration(fTween, fTweenDuration); }

Modified: trunk/zoolib/source/cxx/zoolib/ZTween_Std.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZTween_Std.h	2011-10-21 02:50:27 UTC (rev 2583)
+++ trunk/zoolib/source/cxx/zoolib/ZTween_Std.h	2011-10-21 20:25:48 UTC (rev 2584)
@@ -36,8 +36,12 @@
 :	public ZTween<Val>
 	{
 public:
-	virtual Val ValAt(double iTime)
-		{ return Fun(sMinMax(0.0, iTime, 1.0)); }
+	virtual ZQ<Val> QValAt(double iTime)
+		{
+		if (iTime < 0 || iTime >= 1.0)
+			return null;
+		return Fun(iTime);
+		}
 
 	virtual double Duration()
 		{ return 1; }
@@ -56,8 +60,12 @@
 	:	fTween(iTween)
 		{}
 
-	virtual Val ValAt(double iTime)
-		{ return Fun(fTween->ValAt(iTime)); }
+	virtual ZQ<Val> QValAt(double iTime)
+		{
+		if (ZQ<Param> theQ = fTween->QValAt(iTime))
+			return Fun(*theQ);
+		return null;
+		}
 
 	virtual double Duration()
 		{ return fTween->Duration(); }
@@ -79,8 +87,12 @@
 	:	fTween(iTween)
 		{}
 
-	virtual Val ValAt(double iTime)
-		{ return Val(fTween->ValAt(iTime)); }
+	virtual ZQ<Val> QValAt(double iTime)
+		{
+		if (ZQ<Param> theQ = fTween->QValAt(iTime))
+			return Val(*theQ);
+		return null;
+		}
 
 	virtual double Duration()
 		{ return fTween->Duration(); }
@@ -631,9 +643,10 @@
 public:
 	ZTween_Fun_BackIn(Val iFactor) : fFactor(iFactor) {}
 
-	virtual Val ValAt(double iTime)
+	virtual ZQ<Val> QValAt(double iTime)
 		{
-		iTime = sMinMax(0.0, iTime, 1.0);
+		if (iTime < 0 || iTime > 1.0)
+			return null;
 		return iTime * iTime * ((fFactor + 1 ) * iTime - fFactor);
 		}
 
@@ -663,9 +676,10 @@
 public:
 	ZTween_Fun_BackOut(Val iFactor) : fFactor(iFactor) {}
 
-	virtual Val ValAt(double iTime)
+	virtual ZQ<Val> QValAt(double iTime)
 		{
-		iTime = sMinMax(0.0, iTime, 1.0);
+		if (iTime < 0 || iTime > 1.0)
+			return null;
 		iTime -= 1;
 		return iTime * iTime * ((fFactor + 1) * iTime + fFactor) + 1;
 		}

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2585
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2585&view=rev
Author:   agreen
Date:     2011-10-22 17:55:57 +0000 (Sat, 22 Oct 2011)
Log Message:
-----------
sGetDuration-->spGetDuration
Add ZTween_Null
Use 0 <= iTime < 1

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZTween.h
    trunk/zoolib/source/cxx/zoolib/ZTween_Std.h

Modified: trunk/zoolib/source/cxx/zoolib/ZTween.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZTween.h	2011-10-21 20:25:48 UTC (rev 2584)
+++ trunk/zoolib/source/cxx/zoolib/ZTween.h	2011-10-22 17:55:57 UTC (rev 2585)
@@ -84,9 +84,38 @@
 	virtual double Duration() = 0;
 	};
 
+// =================================================================================================
+#pragma mark -
+#pragma mark * sTween_Null
+
 template <class Val>
-static double sGetDuration(const ZRef<ZTween<Val> >& iTween, ZQ<double>& ioCache)
+class ZTween_Null
 	{
+public:
+	ZTween_Null()
+		{}
+	
+	virtual ZQ<Val> QValAt(double iTime)
+		{ return null; }
+	
+	virtual double Duration()
+		{ return 0; }
+	};
+
+template <class Val>
+ZRef<ZTween<Val> > sTween_Null()
+	{
+	static ZRef<ZTween<Val> > spTween = new ZTween_Null<Val>;
+	return spTween;
+	}
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * spGetDuration
+
+template <class Val>
+double spGetDuration(const ZRef<ZTween<Val> >& iTween, ZQ<double>& ioCache)
+	{
 	if (not ioCache)
 		ioCache = iTween->Duration();
 	return *ioCache;
@@ -111,7 +140,7 @@
 		{ return fCombiner(f0->QValAt(iTime), f1->QValAt(iTime)); }
 
 	virtual double Duration()
-		{ return std::max(sGetDuration(f0, fD0), sGetDuration(f1, fD1)); }
+		{ return std::max(spGetDuration(f0, fD0), spGetDuration(f1, fD1)); }
 
 private:
 	Combiner fCombiner;
@@ -194,7 +223,7 @@
 		{ return fCombiner(f0->QValAt(iTime), f1->QValAt(iTime)); }
 
 	virtual double Duration()
-		{ return std::min(sGetDuration(f0, fD0), sGetDuration(f1, fD1)); }
+		{ return std::min(spGetDuration(f0, fD0), spGetDuration(f1, fD1)); }
 
 private:
 	Combiner fCombiner;
@@ -252,14 +281,14 @@
 // From ZTween
 	virtual ZQ<Val> QValAt(double iTime)
 		{
-		if (iTime < sGetDuration(f0, fD0))
+		if (iTime < spGetDuration(f0, fD0))
 			return f0->QValAt(iTime);
 		else
-			return f1->QValAt(iTime - sGetDuration(f0, fD0));
+			return f1->QValAt(iTime - spGetDuration(f0, fD0));
 		}
 
 	virtual double Duration()
-		{ return sGetDuration(f0, fD0) + sGetDuration(f1, fD1); }
+		{ return spGetDuration(f0, fD0) + spGetDuration(f1, fD1); }
 
 private:
 	const ZRef<ZTween<Val> > f0, f1;
@@ -311,12 +340,12 @@
 // From ZTween
 	virtual ZQ<Val0> QValAt(double iTime)
 		{
-		const double time1 = iTime / sGetDuration(f0, fD0) * sGetDuration(f1, fD1);
+		const double time1 = iTime / spGetDuration(f0, fD0) * spGetDuration(f1, fD1);
 		return fCombiner(f0->QValAt(iTime), f1->QValAt(time1));
 		}
 
 	virtual double Duration()
-		{ return sGetDuration(f0, fD0); }
+		{ return spGetDuration(f0, fD0); }
 
 private:
 	Combiner fCombiner;
@@ -378,13 +407,13 @@
 // From ZTween
 	virtual ZQ<Val> QValAt(double iTime)
 		{
-		const double childDuration = sGetDuration(fTween, fTweenDuration);
+		const double childDuration = spGetDuration(fTween, fTweenDuration);
 		iTime = sMinMax(0.0, iTime, childDuration * fCount);
 		return fTween->QValAt(fmod(iTime, childDuration));
 		}
 
 	virtual double Duration()
-		{ return fCount * sGetDuration(fTween, fTweenDuration); }
+		{ return fCount * spGetDuration(fTween, fTweenDuration); }
 
 private:
 	const ZRef<ZTween<Val> > fTween;
@@ -417,9 +446,9 @@
 // From ZTween
 	virtual ZQ<Val> QValAt(double iTime)
 		{
-		if (iTime < 0 || iTime > fDuration)
+		if (iTime < 0 || iTime >= fDuration)
 			return null;
-		return fTween->QValAt(fmod(iTime, sGetDuration(fTween, fTweenDuration)));
+		return fTween->QValAt(fmod(iTime, spGetDuration(fTween, fTweenDuration)));
 		}
 
 	virtual double Duration()
@@ -456,7 +485,7 @@
 // From ZTween
 	virtual ZQ<Val> QValAt(double iTime)
 		{
-		if (iTime > fDuration)
+		if (iTime >= fDuration)
 			return null;
 		return fTween->QValAt(iTime);
 		}
@@ -494,13 +523,13 @@
 // From ZTween
 	virtual ZQ<Val> QValAt(double iTime)
 		{
-		if (iTime > this->Duration())
+		if (iTime >= this->Duration())
 			return null;
 		return fTween->QValAt(iTime);
 		}
 
 	virtual double Duration()
-		{ return std::min(fAtMost, sGetDuration(fTween, fTweenDuration)); }
+		{ return std::min(fAtMost, spGetDuration(fTween, fTweenDuration)); }
 
 private:
 	const ZRef<ZTween<Val> > fTween;
@@ -533,13 +562,13 @@
 // From ZTween
 	virtual ZQ<Val> QValAt(double iTime)
 		{
-		if (iTime > fAtLeast)
+		if (iTime >= fAtLeast)
 			return null;
-		return fTween->QValAt(std::min(iTime, sGetDuration(fTween, fTweenDuration)));
+		return fTween->QValAt(std::min(iTime, spGetDuration(fTween, fTweenDuration)));
 		}
 
 	virtual double Duration()
-		{ return std::max(fAtLeast, sGetDuration(fTween, fTweenDuration)); }
+		{ return std::max(fAtLeast, spGetDuration(fTween, fTweenDuration)); }
 
 private:
 	const ZRef<ZTween<Val> > fTween;
@@ -574,7 +603,7 @@
 		{ return fTween->QValAt(iTime - fDelay); }
 
 	virtual double Duration()
-		{ return std::max(0.0, sGetDuration(fTween, fTweenDuration) + fDelay); }
+		{ return std::max(0.0, spGetDuration(fTween, fTweenDuration) + fDelay); }
 
 private:
 	const ZRef<ZTween<Val> > fTween;
@@ -610,15 +639,15 @@
 		if (fRate > 0)
 			return fTween->QValAt(iTime / fRate);
 		else
-			return fTween->QValAt(sGetDuration(fTween, fTweenDuration) + iTime/fRate);
+			return fTween->QValAt(spGetDuration(fTween, fTweenDuration) + iTime/fRate);
 		}
 
 	virtual double Duration()
 		{
 		if (fRate > 0)
-			return fRate * sGetDuration(fTween, fTweenDuration);
+			return fRate * spGetDuration(fTween, fTweenDuration);
 		else 
-			return -fRate * sGetDuration(fTween, fTweenDuration);
+			return -fRate * spGetDuration(fTween, fTweenDuration);
 		}
 
 private:
@@ -650,7 +679,7 @@
 
 // From ZTween
 	virtual ZQ<Val> QValAt(double iTime)
-		{ return fTween->QValAt(iTime / sGetDuration(fTween, fTweenDuration)); }
+		{ return fTween->QValAt(iTime / spGetDuration(fTween, fTweenDuration)); }
 
 	virtual double Duration()
 		{ return 1; }
@@ -685,7 +714,7 @@
 // From ZTween
 	virtual ZQ<Val> QValAt(double iTime)
 		{
-		if (iTime < 0 || iTime > fDuration)
+		if (iTime < 0 || iTime >= fDuration)
 			return null;
 		return fVal;
 		}
@@ -737,7 +766,7 @@
 		}
 
 	virtual double Duration()
-		{ return sGetDuration(fTween, fTweenDuration); }
+		{ return spGetDuration(fTween, fTweenDuration); }
 
 private:
 	const ZRef<ZTween<Val> > fTween;

Modified: trunk/zoolib/source/cxx/zoolib/ZTween_Std.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZTween_Std.h	2011-10-21 20:25:48 UTC (rev 2584)
+++ trunk/zoolib/source/cxx/zoolib/ZTween_Std.h	2011-10-22 17:55:57 UTC (rev 2585)
@@ -576,11 +576,6 @@
 template <class Val>
 Val spTweenFun_ElasticIn(double iTime)
 	{
-	if (iTime <= 0)
-		return 0;
-	else if (iTime >= 1)
-		return 1;
-
 	iTime -= 1;
 	return -1 * (pow(2, 10*iTime) * sin((iTime-0.3)*2*M_PI/0.3));
 	}
@@ -607,15 +602,8 @@
 
 template <class Val>
 Val spTweenFun_ElasticOut(double iTime)
-	{
-	if (iTime <= 0)
-		return 0;
-	else if (iTime >= 1)
-		return 1;
+	{ return pow(2, -10*iTime) * sin((iTime-0.3)*2*M_PI/0.3) + 1; }
 
-	return pow(2, -10*iTime) * sin((iTime-0.3)*2*M_PI/0.3) + 1;
-	}
-
 template <class Val>
 ZRef<ZTween<Val> > sTween_ElasticOut()
 	{ return new ZTween_Fun<Val,spTweenFun_ElasticOut>; }
@@ -645,7 +633,7 @@
 
 	virtual ZQ<Val> QValAt(double iTime)
 		{
-		if (iTime < 0 || iTime > 1.0)
+		if (iTime < 0 || iTime >= 1.0)
 			return null;
 		return iTime * iTime * ((fFactor + 1 ) * iTime - fFactor);
 		}
@@ -678,7 +666,7 @@
 
 	virtual ZQ<Val> QValAt(double iTime)
 		{
-		if (iTime < 0 || iTime > 1.0)
+		if (iTime < 0 || iTime >= 1.0)
 			return null;
 		iTime -= 1;
 		return iTime * iTime * ((fFactor + 1) * iTime + fFactor) + 1;

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2586
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2586&view=rev
Author:   agreen
Date:     2011-10-24 14:14:21 +0000 (Mon, 24 Oct 2011)
Log Message:
-----------
Name change ZFuture-->ZDelivery.

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZCallable_Caller.h

Added Paths:
-----------
    trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h
    trunk/zoolib/source/cxx/zoolib/ZPromise.h

Removed Paths:
-------------
    trunk/zoolib/source/cxx/zoolib/ZCallFuture.h
    trunk/zoolib/source/cxx/zoolib/ZFuture.h

Added: trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h	                        (rev 0)
+++ trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h	2011-10-24 14:14:21 UTC (rev 2586)
@@ -0,0 +1,54 @@
+/* -------------------------------------------------------------------------------------------------
+Copyright (c) 2011 Andrew Green
+http://www.zoolib.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------------------------- */
+
+#ifndef __ZCallByCaller__
+#define __ZCallByCaller__ 1
+#include "zconfig.h"
+
+#include "zoolib/ZCaller.h"
+#include "zoolib/ZCallable.h"
+#include "zoolib/ZCallable_Bind.h"
+#include "zoolib/ZCallable_Function.h"
+#include "zoolib/ZPromise.h"
+
+namespace ZooLib {
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * sCallByCaller
+
+template <class T>
+void spCallWithPromise_T
+	(const ZRef<ZPromise<ZQ<T> > >& iPromise, const ZRef<ZCallable<T(void)> >& iCallable)
+	{ iPromise->Set(sQCall(iCallable)); }
+
+template <class T>
+ZRef<ZDelivery<ZQ<T> > > sCallByCaller
+	(const ZRef<ZCaller>& iCaller, const ZRef<ZCallable<T(void)> >& iCallable)
+	{
+	ZRef<ZPromise<ZQ<T> > > thePromise = sPromise<ZQ<T> >();
+	if (iCaller)
+		iCaller->Queue(sBindR(sCallable(spCallWithPromise_T<T>), thePromise, iCallable));
+	return thePromise->Get();
+	}
+
+} // namespace ZooLib
+
+#endif // __ZCallByCaller__

Deleted: trunk/zoolib/source/cxx/zoolib/ZCallFuture.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCallFuture.h	2011-10-22 17:55:57 UTC (rev 2585)
+++ trunk/zoolib/source/cxx/zoolib/ZCallFuture.h	2011-10-24 14:14:21 UTC (rev 2586)
@@ -1,54 +0,0 @@
-/* -------------------------------------------------------------------------------------------------
-Copyright (c) 2011 Andrew Green
-http://www.zoolib.org
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software
-and associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
-BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES
-OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
-OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------------------------- */
-
-#ifndef __ZCallFuture__
-#define __ZCallFuture__ 1
-#include "zconfig.h"
-
-#include "zoolib/ZCaller.h"
-#include "zoolib/ZCallable.h"
-#include "zoolib/ZCallable_Bind.h"
-#include "zoolib/ZCallable_Function.h"
-#include "zoolib/ZFuture.h"
-
-namespace ZooLib {
-
-// =================================================================================================
-#pragma mark -
-#pragma mark * sCallFuture
-
-template <class T>
-void sCallWithPromise_T
-	(const ZRef<ZPromise<ZQ<T> > >& iPromise, const ZRef<ZCallable<T(void)> >& iCallable)
-	{ iPromise->Set(sQCall(iCallable)); }
-
-template <class T>
-ZRef<ZFuture<ZQ<T> > > sCallFuture
-	(const ZRef<ZCaller>& iCaller, const ZRef<ZCallable<T(void)> >& iCallable)
-	{
-	ZRef<ZPromise<ZQ<T> > > thePromise = sPromise<ZQ<T> >();
-	if (iCaller)
-		iCaller->Queue(sBindR(sCallable(sCallWithPromise_T<T>), thePromise, iCallable));
-	return thePromise->Get();
-	}
-
-} // namespace ZooLib
-
-#endif // __ZCallFuture__

Modified: trunk/zoolib/source/cxx/zoolib/ZCallable_Caller.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCallable_Caller.h	2011-10-22 17:55:57 UTC (rev 2585)
+++ trunk/zoolib/source/cxx/zoolib/ZCallable_Caller.h	2011-10-24 14:14:21 UTC (rev 2586)
@@ -22,7 +22,7 @@
 #define __ZCallable_Caller__ 1
 #include "zconfig.h"
 
-#include "zoolib/ZCallFuture.h"
+#include "zoolib/ZCallByCaller.h"
 
 namespace ZooLib {
 namespace ZCallable_Caller {
@@ -52,7 +52,7 @@
 // From ZCallable
 	virtual ZQ<R> QCall()
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			fCallable)->QGet().DGet(null);
 		}
 
@@ -81,7 +81,7 @@
 // From ZCallable
 	virtual ZQ<R> QCall(P0 i0)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0))->QGet().DGet(null);
 		}
 
@@ -110,7 +110,7 @@
 // From ZCallable
 	virtual ZQ<R> QCall(P0 i0, P1 i1)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1))->QGet().DGet(null);
 		}
 
@@ -139,7 +139,7 @@
 // From ZCallable
 	virtual ZQ<R> QCall(P0 i0, P1 i1, P2 i2)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2))->QGet().DGet(null);
 		}
 
@@ -168,7 +168,7 @@
 // From ZCallable
 	virtual ZQ<R> QCall(P0 i0, P1 i1, P2 i2, P3 i3)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3))->QGet().DGet(null);
 		}
 
@@ -198,7 +198,7 @@
 // From ZCallable
 	virtual ZQ<R> QCall(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4))->QGet().DGet(null);
 		}
 
@@ -228,7 +228,7 @@
 // From ZCallable
 	virtual ZQ<R> QCall(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5))->QGet().DGet(null);
 		}
 
@@ -258,7 +258,7 @@
 // From ZCallable
 	virtual ZQ<R> QCall(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5, i6))->QGet().DGet(null);
 		}
 
@@ -288,7 +288,7 @@
 // From ZCallable
 	virtual ZQ<R> QCall(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6, P7 i7)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5, i6, i7))->QGet().DGet(null);
 		}
 
@@ -321,7 +321,7 @@
 		(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6, P7 i7,
 		P8 i8)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5, i6, i7, i8))->QGet().DGet(null);
 		}
 
@@ -354,7 +354,7 @@
 		(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6, P7 i7,
 		P8 i8, P9 i9)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9))->QGet().DGet(null);
 		}
 
@@ -387,7 +387,7 @@
 		(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6, P7 i7,
 		P8 i8, P9 i9, PA iA)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, iA))->QGet().DGet(null);
 		}
 
@@ -420,7 +420,7 @@
 		(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6, P7 i7,
 		P8 i8, P9 i9, PA iA, PB iB)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, iA, iB))->QGet().DGet(null);
 		}
 
@@ -454,7 +454,7 @@
 		(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6, P7 i7,
 		P8 i8, P9 i9, PA iA, PB iB, PC iC)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5, i6, i7,
 			i8, i9, iA, iB, iC))->QGet().DGet(null);
 		}
@@ -489,7 +489,7 @@
 		(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6, P7 i7,
 		P8 i8, P9 i9, PA iA, PB iB, PC iC, PD iD)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5, i6, i7,
 			i8, i9, iA, iB, iC, iD))->QGet().DGet(null);
 		}
@@ -524,7 +524,7 @@
 		(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6, P7 i7,
 		P8 i8, P9 i9, PA iA, PB iB, PC iC, PD iD, PE iE)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5, i6, i7,
 			i8, i9, iA, iB, iC, iD, iE))->QGet().DGet(null);
 		}
@@ -559,7 +559,7 @@
 		(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6, P7 i7,
 		P8 i8, P9 i9, PA iA, PB iB, PC iC, PD iD, PE iE, PF iF)
 		{
-		return sCallFuture(fCaller,
+		return sCallByCaller(fCaller,
 			sBindR(fCallable, i0, i1, i2, i3, i4, i5, i6, i7,
 			i8, i9, iA, iB, iC, iD, iE, iF))->QGet().DGet(null);
 		}

Deleted: trunk/zoolib/source/cxx/zoolib/ZFuture.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZFuture.h	2011-10-22 17:55:57 UTC (rev 2585)
+++ trunk/zoolib/source/cxx/zoolib/ZFuture.h	2011-10-24 14:14:21 UTC (rev 2586)
@@ -1,229 +0,0 @@
-/* -------------------------------------------------------------------------------------------------
-Copyright (c) 2011 Andrew Green
-http://www.zoolib.org
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software
-and associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
-BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES
-OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
-OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------------------------- */
-
-#ifndef __ZFuture__
-#define __ZFuture__ 1
-#include "zconfig.h"
-
-#include "zoolib/ZCountedWithoutFinalize.h"
-#include "zoolib/ZQ.h"
-#include "zoolib/ZRef.h"
-#include "zoolib/ZThread.h"
-
-namespace ZooLib {
-
-template <class T> class ZPromise;
-
-// =================================================================================================
-#pragma mark -
-#pragma mark * ZFuture
-
-template <class T>
-class ZFuture
-:	public ZCountedWithoutFinalize
-	{
-	ZFuture()
-	:	fPromiseExists(true)
-		{}
-
-public:
-	virtual ~ZFuture()
-		{}
-
-	void Wait()
-		{
-		ZAcqMtx acq(fMtx);
-		for (;;)
-			{
-			if (fVal || not fPromiseExists)
-				return;
-			fCnd.Wait(fMtx);
-			}
-		}
-
-	bool WaitFor(double iTimeout)
-		{
-		ZAcqMtx acq(fMtx);
-
-		if (fVal || not fPromiseExists)
-			return true;
-
-		fCnd.WaitFor(fMtx, iTimeout);
-
-		if (fVal || not fPromiseExists)
-			return true;
-
-		return false;
-		}
-
-	bool WaitUntil(ZTime iDeadline)
-		{
-		ZAcqMtx acq(fMtx);
-
-		if (fVal || not fPromiseExists)
-			return true;
-
-		fCnd.WaitUntil(fMtx, iDeadline);
-
-		if (fVal || not fPromiseExists)
-			return true;
-
-		return false;
-		}
-
-	ZQ<T> QGet()
-		{
-		ZAcqMtx acq(fMtx);
-		while (fPromiseExists && not fVal)
-			fCnd.Wait(fMtx);
-		return fVal;
-		}
-
-private:
-	friend class ZPromise<T>;
-	ZMtx fMtx;
-	ZCnd fCnd;
-	bool fPromiseExists;
-	ZQ<T> fVal;
-	};
-
-// =================================================================================================
-#pragma mark -
-#pragma mark * ZPromise
-
-template <class T>
-class ZPromise
-:	public ZCountedWithoutFinalize
-	{
-public:
-	ZPromise()
-	:	fFuture(new ZFuture<T>)
-		{}
-
-	virtual ~ZPromise()
-		{
-		ZAcqMtx acq(fFuture->fMtx);
-		fFuture->fPromiseExists = false;
-		fFuture->fCnd.Broadcast();
-		}
-
-	bool IsSet()
-		{
-		ZAcqMtx acq(fFuture->fMtx);
-		return fFuture->fVal;
-		}
-
-	void Set(const T& iVal)
-		{
-		ZAcqMtx acq(fFuture->fMtx);
-		fFuture->fVal.Set(iVal);
-		fFuture->fCnd.Broadcast();
-		}
-
-	bool SetIfNotSet(const T& iVal)
-		{
-		ZAcqMtx acq(fFuture->fMtx);
-		if (fFuture->fVal)
-			return false;
-		fFuture->fVal.Set(iVal);
-		fFuture->fCnd.Broadcast();
-		return true;
-		}
-
-	ZRef<ZFuture<T> > Get()
-		{ return fFuture; }
-
-private:
-	ZRef<ZFuture<T> > fFuture;
-	};
-
-// =================================================================================================
-#pragma mark -
-#pragma mark * ZPromise<void>
-
-template <>
-class ZPromise<void>
-:	public ZCountedWithoutFinalize
-	{
-public:
-	ZPromise()
-	:	fFuture(new ZFuture<void>)
-		{}
-
-	virtual ~ZPromise()
-		{
-		ZAcqMtx acq(fFuture->fMtx);
-		fFuture->fPromiseExists = false;
-		fFuture->fCnd.Broadcast();
-		}
-
-	bool IsSet()
-		{
-		ZAcqMtx acq(fFuture->fMtx);
-		return fFuture->fVal;
-		}
-
-	void Set()
-		{
-		ZAcqMtx acq(fFuture->fMtx);
-		fFuture->fVal.Set();
-		fFuture->fCnd.Broadcast();
-		}
-
-	bool SetIfNotSet()
-		{
-		ZAcqMtx acq(fFuture->fMtx);
-		if (fFuture->fVal)
-			return false;
-		fFuture->fVal.Set();
-		fFuture->fCnd.Broadcast();
-		return true;
-		}
-
-	ZRef<ZFuture<void> > Get()
-		{ return fFuture; }
-
-private:
-	ZRef<ZFuture<void> > fFuture;
-	};
-
-// =================================================================================================
-#pragma mark -
-#pragma mark * sPromise
-
-template <class T>
-ZRef<ZPromise<T> > sPromise()
-	{ return new ZPromise<T>; }
-
-// =================================================================================================
-#pragma mark -
-#pragma mark * sGetClear
-
-template <class T>
-ZRef<ZFuture<T> > sGetClear(ZRef<ZPromise<T> >& ioPromise)
-	{
-	ZRef<ZFuture<T> > theFuture = ioPromise->Get();
-	ioPromise.Clear();
-	return theFuture;
-	}
-
-} // namespace ZooLib
-
-#endif // __ZFuture__

Added: trunk/zoolib/source/cxx/zoolib/ZPromise.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZPromise.h	                        (rev 0)
+++ trunk/zoolib/source/cxx/zoolib/ZPromise.h	2011-10-24 14:14:21 UTC (rev 2586)
@@ -0,0 +1,229 @@
+/* -------------------------------------------------------------------------------------------------
+Copyright (c) 2011 Andrew Green
+http://www.zoolib.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------------------------- */
+
+#ifndef __ZPromise__
+#define __ZPromise__ 1
+#include "zconfig.h"
+
+#include "zoolib/ZCountedWithoutFinalize.h"
+#include "zoolib/ZQ.h"
+#include "zoolib/ZRef.h"
+#include "zoolib/ZThread.h"
+
+namespace ZooLib {
+
+template <class T> class ZPromise;
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * ZDelivery
+
+template <class T>
+class ZDelivery
+:	public ZCountedWithoutFinalize
+	{
+	ZDelivery()
+	:	fPromiseExists(true)
+		{}
+
+public:
+	virtual ~ZDelivery()
+		{}
+
+	void Wait()
+		{
+		ZAcqMtx acq(fMtx);
+		for (;;)
+			{
+			if (fVal || not fPromiseExists)
+				return;
+			fCnd.Wait(fMtx);
+			}
+		}
+
+	bool WaitFor(double iTimeout)
+		{
+		ZAcqMtx acq(fMtx);
+
+		if (fVal || not fPromiseExists)
+			return true;
+
+		fCnd.WaitFor(fMtx, iTimeout);
+
+		if (fVal || not fPromiseExists)
+			return true;
+
+		return false;
+		}
+
+	bool WaitUntil(ZTime iDeadline)
+		{
+		ZAcqMtx acq(fMtx);
+
+		if (fVal || not fPromiseExists)
+			return true;
+
+		fCnd.WaitUntil(fMtx, iDeadline);
+
+		if (fVal || not fPromiseExists)
+			return true;
+
+		return false;
+		}
+
+	ZQ<T> QGet()
+		{
+		ZAcqMtx acq(fMtx);
+		while (fPromiseExists && not fVal)
+			fCnd.Wait(fMtx);
+		return fVal;
+		}
+
+private:
+	friend class ZPromise<T>;
+	ZMtx fMtx;
+	ZCnd fCnd;
+	bool fPromiseExists;
+	ZQ<T> fVal;
+	};
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * ZPromise
+
+template <class T>
+class ZPromise
+:	public ZCountedWithoutFinalize
+	{
+public:
+	ZPromise()
+	:	fDelivery(new ZDelivery<T>)
+		{}
+
+	virtual ~ZPromise()
+		{
+		ZAcqMtx acq(fDelivery->fMtx);
+		fDelivery->fPromiseExists = false;
+		fDelivery->fCnd.Broadcast();
+		}
+
+	bool IsSet()
+		{
+		ZAcqMtx acq(fDelivery->fMtx);
+		return fDelivery->fVal;
+		}
+
+	void Set(const T& iVal)
+		{
+		ZAcqMtx acq(fDelivery->fMtx);
+		fDelivery->fVal.Set(iVal);
+		fDelivery->fCnd.Broadcast();
+		}
+
+	bool SetIfNotSet(const T& iVal)
+		{
+		ZAcqMtx acq(fDelivery->fMtx);
+		if (fDelivery->fVal)
+			return false;
+		fDelivery->fVal.Set(iVal);
+		fDelivery->fCnd.Broadcast();
+		return true;
+		}
+
+	ZRef<ZDelivery<T> > Get()
+		{ return fDelivery; }
+
+private:
+	ZRef<ZDelivery<T> > fDelivery;
+	};
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * ZPromise<void>
+
+template <>
+class ZPromise<void>
+:	public ZCountedWithoutFinalize
+	{
+public:
+	ZPromise()
+	:	fDelivery(new ZDelivery<void>)
+		{}
+
+	virtual ~ZPromise()
+		{
+		ZAcqMtx acq(fDelivery->fMtx);
+		fDelivery->fPromiseExists = false;
+		fDelivery->fCnd.Broadcast();
+		}
+
+	bool IsSet()
+		{
+		ZAcqMtx acq(fDelivery->fMtx);
+		return fDelivery->fVal;
+		}
+
+	void Set()
+		{
+		ZAcqMtx acq(fDelivery->fMtx);
+		fDelivery->fVal.Set();
+		fDelivery->fCnd.Broadcast();
+		}
+
+	bool SetIfNotSet()
+		{
+		ZAcqMtx acq(fDelivery->fMtx);
+		if (fDelivery->fVal)
+			return false;
+		fDelivery->fVal.Set();
+		fDelivery->fCnd.Broadcast();
+		return true;
+		}
+
+	ZRef<ZDelivery<void> > Get()
+		{ return fDelivery; }
+
+private:
+	ZRef<ZDelivery<void> > fDelivery;
+	};
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * sPromise
+
+template <class T>
+ZRef<ZPromise<T> > sPromise()
+	{ return new ZPromise<T>; }
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * sGetClear
+
+template <class T>
+ZRef<ZDelivery<T> > sGetClear(ZRef<ZPromise<T> >& ioPromise)
+	{
+	ZRef<ZDelivery<T> > theDelivery = ioPromise->Get();
+	ioPromise.Clear();
+	return theDelivery;
+	}
+
+} // namespace ZooLib
+
+#endif // __ZPromise__

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2587
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2587&view=rev
Author:   agreen
Date:     2011-10-24 14:39:33 +0000 (Mon, 24 Oct 2011)
Log Message:
-----------
The short method names Get/Set were punchy, but because promises and their deliveries are often mixed up with ZQ and ZVal stuff things often got confusing.

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h
    trunk/zoolib/source/cxx/zoolib/ZPromise.h

Modified: trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h	2011-10-24 14:14:21 UTC (rev 2586)
+++ trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h	2011-10-24 14:39:33 UTC (rev 2587)
@@ -37,7 +37,7 @@
 template <class T>
 void spCallWithPromise_T
 	(const ZRef<ZPromise<ZQ<T> > >& iPromise, const ZRef<ZCallable<T(void)> >& iCallable)
-	{ iPromise->Set(sQCall(iCallable)); }
+	{ iPromise->Deliver(sQCall(iCallable)); }
 
 template <class T>
 ZRef<ZDelivery<ZQ<T> > > sCallByCaller
@@ -46,7 +46,7 @@
 	ZRef<ZPromise<ZQ<T> > > thePromise = sPromise<ZQ<T> >();
 	if (iCaller)
 		iCaller->Queue(sBindR(sCallable(spCallWithPromise_T<T>), thePromise, iCallable));
-	return thePromise->Get();
+	return thePromise->GetDelivery();
 	}
 
 } // namespace ZooLib

Modified: trunk/zoolib/source/cxx/zoolib/ZPromise.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZPromise.h	2011-10-24 14:14:21 UTC (rev 2586)
+++ trunk/zoolib/source/cxx/zoolib/ZPromise.h	2011-10-24 14:39:33 UTC (rev 2587)
@@ -108,7 +108,7 @@
 #pragma mark -
 #pragma mark * ZPromise
 
-template <class T>
+template <class T = void>
 class ZPromise
 :	public ZCountedWithoutFinalize
 	{
@@ -124,20 +124,20 @@
 		fDelivery->fCnd.Broadcast();
 		}
 
-	bool IsSet()
+	bool IsDelivered()
 		{
 		ZAcqMtx acq(fDelivery->fMtx);
 		return fDelivery->fVal;
 		}
 
-	void Set(const T& iVal)
+	void Deliver(const T& iVal)
 		{
 		ZAcqMtx acq(fDelivery->fMtx);
 		fDelivery->fVal.Set(iVal);
 		fDelivery->fCnd.Broadcast();
 		}
 
-	bool SetIfNotSet(const T& iVal)
+	bool QDeliver(const T& iVal)
 		{
 		ZAcqMtx acq(fDelivery->fMtx);
 		if (fDelivery->fVal)
@@ -147,7 +147,7 @@
 		return true;
 		}
 
-	ZRef<ZDelivery<T> > Get()
+	ZRef<ZDelivery<T> > GetDelivery()
 		{ return fDelivery; }
 
 private:
@@ -174,20 +174,20 @@
 		fDelivery->fCnd.Broadcast();
 		}
 
-	bool IsSet()
+	bool IsDelivered()
 		{
 		ZAcqMtx acq(fDelivery->fMtx);
 		return fDelivery->fVal;
 		}
 
-	void Set()
+	void Deliver()
 		{
 		ZAcqMtx acq(fDelivery->fMtx);
 		fDelivery->fVal.Set();
 		fDelivery->fCnd.Broadcast();
 		}
 
-	bool SetIfNotSet()
+	bool QDeliver()
 		{
 		ZAcqMtx acq(fDelivery->fMtx);
 		if (fDelivery->fVal)
@@ -197,7 +197,7 @@
 		return true;
 		}
 
-	ZRef<ZDelivery<void> > Get()
+	ZRef<ZDelivery<void> > GetDelivery()
 		{ return fDelivery; }
 
 private:
@@ -208,6 +208,10 @@
 #pragma mark -
 #pragma mark * sPromise
 
+inline
+ZRef<ZPromise<void> > sPromise()
+	{ return new ZPromise<void>; }
+
 template <class T>
 ZRef<ZPromise<T> > sPromise()
 	{ return new ZPromise<T>; }
@@ -217,9 +221,9 @@
 #pragma mark * sGetClear
 
 template <class T>
-ZRef<ZDelivery<T> > sGetClear(ZRef<ZPromise<T> >& ioPromise)
+ZRef<ZDelivery<T> > sGetDeliveryClearPromise(ZRef<ZPromise<T> >& ioPromise)
 	{
-	ZRef<ZDelivery<T> > theDelivery = ioPromise->Get();
+	ZRef<ZDelivery<T> > theDelivery = ioPromise->GetDelivery();
 	ioPromise.Clear();
 	return theDelivery;
 	}

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2589
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2589&view=rev
Author:   agreen
Date:     2011-10-24 15:17:31 +0000 (Mon, 24 Oct 2011)
Log Message:
-----------
Some tweaks.

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h
    trunk/zoolib/source/cxx/zoolib/ZCallScheduler.cpp
    trunk/zoolib/source/cxx/zoolib/ZCaller_CFRunLoop.cpp
    trunk/zoolib/source/cxx/zoolib/ZCaller_WinMessageLoop.cpp
    trunk/zoolib/source/cxx/zoolib/ZPromise.h
    trunk/zoolib/source/cxx/zoolib/ZUtil_CarbonEvents.cpp

Modified: trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h	2011-10-24 14:46:25 UTC (rev 2588)
+++ trunk/zoolib/source/cxx/zoolib/ZCallByCaller.h	2011-10-24 15:17:31 UTC (rev 2589)
@@ -23,7 +23,6 @@
 #include "zconfig.h"
 
 #include "zoolib/ZCaller.h"
-#include "zoolib/ZCallable.h"
 #include "zoolib/ZCallable_Bind.h"
 #include "zoolib/ZCallable_Function.h"
 #include "zoolib/ZPromise.h"

Modified: trunk/zoolib/source/cxx/zoolib/ZCallScheduler.cpp
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCallScheduler.cpp	2011-10-24 14:46:25 UTC (rev 2588)
+++ trunk/zoolib/source/cxx/zoolib/ZCallScheduler.cpp	2011-10-24 15:17:31 UTC (rev 2589)
@@ -121,19 +121,19 @@
 			}
 		else
 			{
-			set<TimeJob>::iterator front = fTimeJobs.begin();
-			const double delta = front->first - ZTime::sSystem();
+			set<TimeJob>::iterator begin = fTimeJobs.begin();
+			const double delta = begin->first - ZTime::sSystem();
 			if (delta > 0)
 				{
 				fCnd.WaitFor(fMtxR, delta);
 				}
 			else
 				{
-				ZRef<ZCaller> theCaller = front->second.first;
-				ZRef<ZCallable_Void> theCallable = front->second.second;
+				ZRef<ZCaller> theCaller = begin->second.first;
+				ZRef<ZCallable_Void> theCallable = begin->second.second;
 
-				ZUtil_STL::sEraseMustContain(fJobTimes, make_pair(front->second, front->first));
-				fTimeJobs.erase(front);
+				ZUtil_STL::sEraseMustContain(fJobTimes, make_pair(begin->second, begin->first));
+				fTimeJobs.erase(begin);
 
 				guard.Release();
 

Modified: trunk/zoolib/source/cxx/zoolib/ZCaller_CFRunLoop.cpp
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCaller_CFRunLoop.cpp	2011-10-24 14:46:25 UTC (rev 2588)
+++ trunk/zoolib/source/cxx/zoolib/ZCaller_CFRunLoop.cpp	2011-10-24 15:17:31 UTC (rev 2589)
@@ -35,10 +35,9 @@
 	static CFRunLoopRef spRunLoopMain = ::CFRunLoopGetCurrent();
 #endif
 
-static ZRef<ZCaller_CFRunLoop> spCaller;
-
 ZRef<ZCaller_CFRunLoop> ZCaller_CFRunLoop::sMain()
 	{
+	static ZRef<ZCaller_CFRunLoop> spCaller;
 	if (!spCaller)
 		{
 		#if MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4

Modified: trunk/zoolib/source/cxx/zoolib/ZCaller_WinMessageLoop.cpp
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCaller_WinMessageLoop.cpp	2011-10-24 14:46:25 UTC (rev 2588)
+++ trunk/zoolib/source/cxx/zoolib/ZCaller_WinMessageLoop.cpp	2011-10-24 15:17:31 UTC (rev 2589)
@@ -52,7 +52,6 @@
 		{
 		::DestroyWindow(fHWND);
 		ZAssert(not fHWND);
-		//fHWND = nullptr;
 		}
 
 	ZCaller_EventLoop::Finalize();
@@ -64,18 +63,21 @@
 		{
 		::DestroyWindow(fHWND);
 		ZAssert(not fHWND);
-		//fHWND = nullptr;
 		}
 	ZCaller_EventLoop::pDiscardPending();
 	}
 
-static UINT spMSG_Invoke = ::RegisterWindowMessageW(L"ZCaller_WinMessageLoop::Invoke");
+static UINT spGetMSG()
+	{
+	static UINT spMSG = ::RegisterWindowMessageW(L"ZCaller_WinMessageLoop::Invoke");
+	return spMSG;
+	}
 
 bool ZCaller_WinMessageLoop::pTrigger()
 	{
 	if (fHWND)
 		{
-		::PostMessageW(fHWND, spMSG_Invoke, 0, 0);
+		::PostMessageW(fHWND, spGetMSG(), 0, 0);
 		return true;
 		}
 	return false;
@@ -84,7 +86,7 @@
 LRESULT ZCaller_WinMessageLoop::pWindowProc
 	(WNDPROC iWNDPROC, HWND iHWND, UINT iMessage, WPARAM iWPARAM, LPARAM iLPARAM)
 	{
-	if (iMessage == spMSG_Invoke)
+	if (iMessage == spGetMSG())
 		{
 		ZCaller_EventLoop::pCall();
 		return 0;

Modified: trunk/zoolib/source/cxx/zoolib/ZPromise.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZPromise.h	2011-10-24 14:46:25 UTC (rev 2588)
+++ trunk/zoolib/source/cxx/zoolib/ZPromise.h	2011-10-24 15:17:31 UTC (rev 2589)
@@ -140,9 +140,8 @@
 	bool QDeliver(const T& iVal)
 		{
 		ZAcqMtx acq(fDelivery->fMtx);
-		if (fDelivery->fVal)
+		if (not fDelivery->fVal.QSet(iVal))
 			return false;
-		fDelivery->fVal.Set(iVal);
 		fDelivery->fCnd.Broadcast();
 		return true;
 		}
@@ -190,9 +189,8 @@
 	bool QDeliver()
 		{
 		ZAcqMtx acq(fDelivery->fMtx);
-		if (fDelivery->fVal)
+		if (not fDelivery->fVal.QSet())
 			return false;
-		fDelivery->fVal.Set();
 		fDelivery->fCnd.Broadcast();
 		return true;
 		}

Modified: trunk/zoolib/source/cxx/zoolib/ZUtil_CarbonEvents.cpp
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZUtil_CarbonEvents.cpp	2011-10-24 14:46:25 UTC (rev 2588)
+++ trunk/zoolib/source/cxx/zoolib/ZUtil_CarbonEvents.cpp	2011-10-24 15:17:31 UTC (rev 2589)
@@ -32,7 +32,7 @@
 
 using std::string;
 
-#if defined(UNIVERSAL_INTERFACES_VERSION) && UNIVERSAL_INTERFACES_VERSION <= 0x0341
+#if !defined(UNIVERSAL_INTERFACES_VERSION) || UNIVERSAL_INTERFACES_VERSION <= 0x0341
 	#define USING_ANCIENT_HEADERS 1
 #else
 	#define USING_ANCIENT_HEADERS 0

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2590
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2590&view=rev
Author:   agreen
Date:     2011-10-25 17:16:58 +0000 (Tue, 25 Oct 2011)
Log Message:
-----------
Comments and neat-freak.

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZCallable_Compound.h
    trunk/zoolib/source/cxx/zoolib/ZCallable_Set.h

Modified: trunk/zoolib/source/cxx/zoolib/ZCallable_Compound.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCallable_Compound.h	2011-10-24 15:17:31 UTC (rev 2589)
+++ trunk/zoolib/source/cxx/zoolib/ZCallable_Compound.h	2011-10-25 17:16:58 UTC (rev 2590)
@@ -28,7 +28,7 @@
 
 // =================================================================================================
 #pragma mark -
-#pragma mark * ZCallable_Apply
+#pragma mark * sCallable_Apply
 
 template <class A, class B, class C>
 class ZCallable_Apply
@@ -53,10 +53,6 @@
 	const ZRef<ZCallable<B(C)> > fCallable;
 	};
 
-// =================================================================================================
-#pragma mark -
-#pragma mark * sCallable_Apply
-
 template <class A, class B, class C>
 ZRef<ZCallable<A(C)> >
 sCallable_Apply(const ZRef<ZCallable<A(B)> >& iApply, const ZRef<ZCallable<B(C)> >& iCallable)
@@ -64,7 +60,7 @@
 
 // =================================================================================================
 #pragma mark -
-#pragma mark * ZCallable_Seq
+#pragma mark * sCallable_Seq
 
 template <class R0, class R1>
 class ZCallable_Seq
@@ -95,7 +91,7 @@
 
 // =================================================================================================
 #pragma mark -
-#pragma mark * ZCallable_For
+#pragma mark * sCallable_For
 
 template <class R_Init, class R_Inc>
 class ZCallable_For
@@ -132,7 +128,7 @@
 
 // =================================================================================================
 #pragma mark -
-#pragma mark * ZCallable_If
+#pragma mark * sCallable_If
 
 template <class R>
 class ZCallable_If
@@ -172,7 +168,7 @@
 
 // =================================================================================================
 #pragma mark -
-#pragma mark * Makers
+#pragma mark * sCallable_Repeat
 
 template<class R>
 class ZCallable_Repeat
@@ -207,7 +203,7 @@
 
 // =================================================================================================
 #pragma mark -
-#pragma mark * Makers
+#pragma mark * sCallable_While
 
 template <class R>
 class ZCallable_While

Modified: trunk/zoolib/source/cxx/zoolib/ZCallable_Set.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCallable_Set.h	2011-10-24 15:17:31 UTC (rev 2589)
+++ trunk/zoolib/source/cxx/zoolib/ZCallable_Set.h	2011-10-25 17:16:58 UTC (rev 2590)
@@ -44,24 +44,25 @@
 public:
 	typedef ZCallable<void(void)> Callable;
 
-	void Insert(ZRef<Callable> iCallable)
-		{ fCallables.Insert(iCallable); }
-
-	void Erase(ZRef<Callable> iCallable)
-		{ fCallables.Erase(iCallable); }
-
+// From ZCallable
 	ZQ<void> QCall()
 		{
 		for (ZSafeSetIterConst<ZRef<Callable> > iter = fCallables; /*no test*/; /*no inc*/)
 			{
-			if (ZQ<ZRef<Callable>,false> theQ = iter.QReadInc())
-				break;
+			if (ZQ<ZRef<Callable> > theQ = iter.QReadInc())
+				sCall(theQ.Get());
 			else
-				sCall(theQ.Get());
+				return notnull;
 			}
-		return notnull;
 		}
 
+// Our protocol
+	void Insert(ZRef<Callable> iCallable)
+		{ fCallables.Insert(iCallable); }
+
+	void Erase(ZRef<Callable> iCallable)
+		{ fCallables.Erase(iCallable); }
+
 private:
 	ZSafeSet<ZRef<Callable> > fCallables;
 	};
@@ -77,24 +78,25 @@
 public:
 	typedef ZCallable<void(P0)> Callable;
 
-	void Insert(ZRef<Callable> iCallable)
-		{ fCallables.Insert(iCallable); }
-
-	void Erase(ZRef<Callable> iCallable)
-		{ fCallables.Erase(iCallable); }
-
+// From ZCallable
 	ZQ<void> QCall(P0 i0)
 		{
 		for (ZSafeSetIterConst<ZRef<Callable> > iter = fCallables; /*no test*/; /*no inc*/)
 			{
-			if (ZQ<ZRef<Callable>,false> theQ = iter.QReadInc())
-				break;
+			if (ZQ<ZRef<Callable> > theQ = iter.QReadInc())
+				sCall(theQ.Get(), i0);
 			else
-				sCall(theQ.Get(), i0);
+				return notnull;
 			}
-		return notnull;
 		}
 
+// Our protocol
+	void Insert(ZRef<Callable> iCallable)
+		{ fCallables.Insert(iCallable); }
+
+	void Erase(ZRef<Callable> iCallable)
+		{ fCallables.Erase(iCallable); }
+
 private:
 	ZSafeSet<ZRef<Callable> > fCallables;
 	};
@@ -110,24 +112,25 @@
 public:
 	typedef ZCallable<void(P0,P1)> Callable;
 
-	void Insert(ZRef<Callable> iCallable)
-		{ fCallables.Insert(iCallable); }
-
-	void Erase(ZRef<Callable> iCallable)
-		{ fCallables.Erase(iCallable); }
-
+// From ZCallable
 	ZQ<void> QCall(P0 i0, P1 i1)
 		{
 		for (ZSafeSetIterConst<ZRef<Callable> > iter = fCallables; /*no test*/; /*no inc*/)
 			{
-			if (ZQ<ZRef<Callable>,false> theQ = iter.QReadInc())
-				break;
+			if (ZQ<ZRef<Callable> > theQ = iter.QReadInc())
+				sCall(theQ.Get(), i0, i1);
 			else
-				sCall(theQ.Get(), i0, i1);
+				return notnull;
 			}
-		return notnull;
 		}
 
+// Our protocol
+	void Insert(ZRef<Callable> iCallable)
+		{ fCallables.Insert(iCallable); }
+
+	void Erase(ZRef<Callable> iCallable)
+		{ fCallables.Erase(iCallable); }
+
 private:
 	ZSafeSet<ZRef<Callable> > fCallables;
 	};
@@ -143,24 +146,25 @@
 public:
 	typedef ZCallable<void(P0,P1,P2)> Callable;
 
-	void Insert(ZRef<Callable> iCallable)
-		{ fCallables.Insert(iCallable); }
-
-	void Erase(ZRef<Callable> iCallable)
-		{ fCallables.Erase(iCallable); }
-
+// From ZCallable
 	ZQ<void> QCall(P0 i0, P1 i1, P2 i2)
 		{
 		for (ZSafeSetIterConst<ZRef<Callable> > iter = fCallables; /*no test*/; /*no inc*/)
 			{
-			if (ZQ<ZRef<Callable>,false> theQ = iter.QReadInc())
-				break;
+			if (ZQ<ZRef<Callable> > theQ = iter.QReadInc())
+				sCall(theQ.Get(), i0, i1, i2);
 			else
-				sCall(theQ.Get(), i0, i1, i2);
+				return notnull;
 			}
-		return notnull;
 		}
 
+// Our protocol
+	void Insert(ZRef<Callable> iCallable)
+		{ fCallables.Insert(iCallable); }
+
+	void Erase(ZRef<Callable> iCallable)
+		{ fCallables.Erase(iCallable); }
+
 private:
 	ZSafeSet<ZRef<Callable> > fCallables;
 	};
@@ -176,24 +180,25 @@
 public:
 	typedef ZCallable<void(P0,P1,P2,P3)> Callable;
 
-	void Insert(ZRef<Callable> iCallable)
-		{ fCallables.Insert(iCallable); }
-
-	void Erase(ZRef<Callable> iCallable)
-		{ fCallables.Erase(iCallable); }
-
+// From ZCallable
 	ZQ<void> QCall(P0 i0, P1 i1, P2 i2, P3 i3)
 		{
 		for (ZSafeSetIterConst<ZRef<Callable> > iter = fCallables; /*no test*/; /*no inc*/)
 			{
-			if (ZQ<ZRef<Callable>,false> theQ = iter.QReadInc())
-				break;
+			if (ZQ<ZRef<Callable> > theQ = iter.QReadInc())
+				sCall(theQ.Get(), i0, i1, i2, i3);
 			else
-				sCall(theQ.Get(), i0, i1, i2, i3);
+				return notnull;
 			}
-		return notnull;
 		}
 
+// Our protocol
+	void Insert(ZRef<Callable> iCallable)
+		{ fCallables.Insert(iCallable); }
+
+	void Erase(ZRef<Callable> iCallable)
+		{ fCallables.Erase(iCallable); }
+
 private:
 	ZSafeSet<ZRef<Callable> > fCallables;
 	};
@@ -209,24 +214,25 @@
 public:
 	typedef ZCallable<void(P0,P1,P2,P3,P4)> Callable;
 
-	void Insert(ZRef<Callable> iCallable)
-		{ fCallables.Insert(iCallable); }
-
-	void Erase(ZRef<Callable> iCallable)
-		{ fCallables.Erase(iCallable); }
-
+// From ZCallable
 	ZQ<void> QCall(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4)
 		{
 		for (ZSafeSetIterConst<ZRef<Callable> > iter = fCallables; /*no test*/; /*no inc*/)
 			{
-			if (ZQ<ZRef<Callable>,false> theQ = iter.QReadInc())
-				break;
+			if (ZQ<ZRef<Callable> > theQ = iter.QReadInc())
+				sCall(theQ.Get(), i0, i1, i2, i3, i4);
 			else
-				sCall(theQ.Get(), i0, i1, i2, i3, i4);
+				return notnull;
 			}
-		return notnull;
 		}
 
+// Our protocol
+	void Insert(ZRef<Callable> iCallable)
+		{ fCallables.Insert(iCallable); }
+
+	void Erase(ZRef<Callable> iCallable)
+		{ fCallables.Erase(iCallable); }
+
 private:
 	ZSafeSet<ZRef<Callable> > fCallables;
 	};
@@ -242,24 +248,25 @@
 public:
 	typedef ZCallable<void(P0,P1,P2,P3,P4,P5)> Callable;
 
-	void Insert(ZRef<Callable> iCallable)
-		{ fCallables.Insert(iCallable); }
-
-	void Erase(ZRef<Callable> iCallable)
-		{ fCallables.Erase(iCallable); }
-
+// From ZCallable
 	ZQ<void> QCall(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5)
 		{
 		for (ZSafeSetIterConst<ZRef<Callable> > iter = fCallables; /*no test*/; /*no inc*/)
 			{
-			if (ZQ<ZRef<Callable>,false> theQ = iter.QReadInc())
-				break;
+			if (ZQ<ZRef<Callable> > theQ = iter.QReadInc())
+				sCall(theQ.Get(), i0, i1, i2, i3, i4, i5);
 			else
-				sCall(theQ.Get(), i0, i1, i2, i3, i4, i5);
+				return notnull;
 			}
-		return notnull;
 		}
 
+// Our protocol
+	void Insert(ZRef<Callable> iCallable)
+		{ fCallables.Insert(iCallable); }
+
+	void Erase(ZRef<Callable> iCallable)
+		{ fCallables.Erase(iCallable); }
+
 private:
 	ZSafeSet<ZRef<Callable> > fCallables;
 	};
@@ -275,22 +282,16 @@
 public:
 	typedef ZCallable<void(P0,P1,P2,P3,P4,P5,P6)> Callable;
 
-	void Insert(ZRef<Callable> iCallable)
-		{ fCallables.Insert(iCallable); }
-
-	void Erase(ZRef<Callable> iCallable)
-		{ fCallables.Erase(iCallable); }
-
+// From ZCallable
 	ZQ<void> QCall(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6)
 		{
 		for (ZSafeSetIterConst<ZRef<Callable> > iter = fCallables; /*no test*/; /*no inc*/)
 			{
-			if (ZQ<ZRef<Callable>,false> theQ = iter.QReadInc())
-				break;
+			if (ZQ<ZRef<Callable> > theQ = iter.QReadInc())
+				sCall(theQ.Get(), i0, i1, i2, i3, i4, i5, i6);
 			else
-				sCall(theQ.Get(), i0, i1, i2, i3, i4, i5, i6);
+				return notnull;
 			}
-		return notnull;
 		}
 
 private:
@@ -308,24 +309,25 @@
 public:
 	typedef ZCallable<void(P0,P1,P2,P3,P4,P5,P6,P7)> Callable;
 
-	void Insert(ZRef<Callable> iCallable)
-		{ fCallables.Insert(iCallable); }
-
-	void Erase(ZRef<Callable> iCallable)
-		{ fCallables.Erase(iCallable); }
-
+// From ZCallable
 	ZQ<void> QCall(P0 i0, P1 i1, P2 i2, P3 i3, P4 i4, P5 i5, P6 i6, P7 i7)
 		{
 		for (ZSafeSetIterConst<ZRef<Callable> > iter = fCallables; /*no test*/; /*no inc*/)
 			{
-			if (ZQ<ZRef<Callable>,false> theQ = iter.QReadInc())
-				break;
+			if (ZQ<ZRef<Callable> > theQ = iter.QReadInc())
+				sCall(theQ.Get(), i0, i1, i2, i3, i4, i5, i6, i7);
 			else
-				sCall(theQ.Get(), i0, i1, i2, i3, i4, i5, i6, i7);
+				return notnull;
 			}
-		return notnull;
 		}
 
+// Our protocol
+	void Insert(ZRef<Callable> iCallable)
+		{ fCallables.Insert(iCallable); }
+
+	void Erase(ZRef<Callable> iCallable)
+		{ fCallables.Erase(iCallable); }
+
 private:
 	ZSafeSet<ZRef<Callable> > fCallables;
 	};

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2597
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2597&view=rev
Author:   agreen
Date:     2011-10-29 15:19:22 +0000 (Sat, 29 Oct 2011)
Log Message:
-----------
Move ZTime-dependent cogs into ZCog_Std.

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZCog.h

Added Paths:
-----------
    trunk/zoolib/source/cxx/zoolib/ZCog_Std.h

Modified: trunk/zoolib/source/cxx/zoolib/ZCog.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCog.h	2011-10-29 15:18:38 UTC (rev 2596)
+++ trunk/zoolib/source/cxx/zoolib/ZCog.h	2011-10-29 15:19:22 UTC (rev 2597)
@@ -691,7 +691,7 @@
 #pragma mark * sCog_While
 
 template <class Param>
-ZCog<Param> sCog_While(const ZCog<Param>& iCog_Init, const ZCog<Param>& iCog);
+ZCog<Param> spCog_While(const ZCog<Param>& iCog_Init, const ZCog<Param>& iCog);
 
 template <class Param>
 ZCog<Param> spCogFun_While(const ZCog<Param>& iSelf, Param iParam,
@@ -709,14 +709,20 @@
 	if (not newCog)
 		return null;
 
-	if (sIsTerm(newCog))
-		return sCallCog(sCog_While(iCog_Init, iCog_Init), iParam); //## Dangerous
+	if (not sIsTerm(newCog))
+		return spCog_While(iCog_Init, newCog);
+
+	// To get unbroken repetition on hitting a term we need to call the new cog.
+	// Only do so if this was not the first time, otherwise we're likely to
+	// recurse indefinitely and blow the stack.
+	if (iCog_Init == iCog)
+		return spCog_While(iCog_Init, iCog_Init);
 	else
-		return sCog_While(iCog_Init, newCog);
+		return sCallCog(spCog_While(iCog_Init, iCog_Init), iParam);
 	}
 
 template <class Param>
-ZCog<Param> sCog_While(const ZCog<Param>& iCog_Init, const ZCog<Param>& iCog)
+ZCog<Param> spCog_While(const ZCog<Param>& iCog_Init, const ZCog<Param>& iCog)
 	{
 	static ZMACRO_auto(spCallable, sCallable(spCogFun_While<Param>));
 	return sBindR(spCallable, iCog_Init, iCog);
@@ -729,7 +735,7 @@
 		{
 		if (sIsTerm(iCallable))
 			return iCallable;
-		return sCog_While<Param>(iCallable, iCallable);
+		return spCog_While<Param>(iCallable, iCallable);
 		}
 	return null;
 	}
@@ -779,66 +785,6 @@
 	const ZRef<ZCallable<ZCog<Param>(const ZCog<Param>&,Param)> >& iCallable)
 	{ return spCog_Repeat<Param>(iCount, iCallable, iCallable); }
 
-// =================================================================================================
-#pragma mark -
-#pragma mark * sCog_DelayUntil
-
-template <class Param>
-ZCog<Param> spCogFun_DelayUntil(const ZCog<Param>& iSelf, Param iParam,
-	ZTime iSystemTime)
-	{
-	if (ZTime::sSystem() > iSystemTime)
-		return sCog_Term<Param>();
-	return iSelf;
-	}
-
-template <class Param>
-ZCog<Param> sCog_DelayUntil(ZTime iSystemTime)
-	{
-	static ZMACRO_auto(spCallable, sCallable(spCogFun_DelayUntil<Param>));
-	return sBindR(spCallable, iSystemTime);
-	}
-
-// =================================================================================================
-#pragma mark -
-#pragma mark * sCog_DelayFor
-
-template <class Param>
-ZCog<Param> spCogFun_DelayFor(const ZCog<Param>& iSelf, Param iParam,
-	double iDelay)
-	{ return sCallCog(sCog_DelayUntil<Param>(ZTime::sSystem() + iDelay), iParam); }
-
-template <class Param>
-ZCog<Param> sCog_DelayFor(double iDelay)
-	{
-	static ZMACRO_auto(spCallable, sCallable(spCogFun_DelayFor<Param>));
-	return sBindR(spCallable, iDelay);
-	}
-
-// =================================================================================================
-#pragma mark -
-#pragma mark * sCog_StartAt, sCog_StopAt, sCog_StartAfter, sCog_StopAfter
-
-template <class Param>
-ZCog<Param> sCog_StartAt(ZTime iSystemTime,
-	const ZRef<ZCallable<ZCog<Param>(const ZCog<Param>&,Param)> >& iCallable)
-	{ return sCog_DelayUntil<Param>(iSystemTime) | iCallable; }
-
-template <class Param>
-ZCog<Param> sCog_StopAt(ZTime iSystemTime,
-	const ZRef<ZCallable<ZCog<Param>(const ZCog<Param>&,Param)> >& iCallable)
-	{ return sCog_DelayUntil<Param>(iSystemTime) * iCallable; }
-
-template <class Param>
-ZCog<Param> sCog_StartAfter(double iDelay,
-	const ZRef<ZCallable<ZCog<Param>(const ZCog<Param>&,Param)> >iCallable)
-	{ return sCog_DelayFor<Param>(iDelay) | iCallable; }
-
-template <class Param>
-ZCog<Param> sCog_StopAfter(double iDelay,
-	const ZRef<ZCallable<ZCog<Param>(const ZCog<Param>&,Param)> >iCallable)
-	{ return sCog_DelayFor<Param>(iDelay) * iCallable; }
-
 } // namespace ZooLib
 
 #endif // __ZCog__

Added: trunk/zoolib/source/cxx/zoolib/ZCog_Std.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZCog_Std.h	                        (rev 0)
+++ trunk/zoolib/source/cxx/zoolib/ZCog_Std.h	2011-10-29 15:19:22 UTC (rev 2597)
@@ -0,0 +1,91 @@
+/* -------------------------------------------------------------------------------------------------
+Copyright (c) 2011 Andrew Green
+http://www.zoolib.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------------------------- */
+
+#ifndef __ZCog_Std__
+#define __ZCog_Std__ 1
+
+#include "zoolib/ZCog.h"
+#include "zoolib/ZTime.h"
+
+namespace ZooLib {
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * sCog_DelayUntil
+
+template <class Param>
+ZCog<Param> spCogFun_DelayUntil(const ZCog<Param>& iSelf, Param iParam,
+	ZTime iSystemTime)
+	{
+	if (ZTime::sSystem() > iSystemTime)
+		return sCog_Term<Param>();
+	return iSelf;
+	}
+
+template <class Param>
+ZCog<Param> sCog_DelayUntil(ZTime iSystemTime)
+	{
+	static ZMACRO_auto(spCallable, sCallable(spCogFun_DelayUntil<Param>));
+	return sBindR(spCallable, iSystemTime);
+	}
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * sCog_DelayFor
+
+template <class Param>
+ZCog<Param> spCogFun_DelayFor(const ZCog<Param>& iSelf, Param iParam,
+	double iDelay)
+	{ return sCallCog(sCog_DelayUntil<Param>(ZTime::sSystem() + iDelay), iParam); }
+
+template <class Param>
+ZCog<Param> sCog_DelayFor(double iDelay)
+	{
+	static ZMACRO_auto(spCallable, sCallable(spCogFun_DelayFor<Param>));
+	return sBindR(spCallable, iDelay);
+	}
+
+// =================================================================================================
+#pragma mark -
+#pragma mark * sCog_StartAt, sCog_StopAt, sCog_StartAfter, sCog_StopAfter
+
+template <class Param>
+ZCog<Param> sCog_StartAt(ZTime iSystemTime,
+	const ZRef<ZCallable<ZCog<Param>(const ZCog<Param>&,Param)> >& iCallable)
+	{ return sCog_DelayUntil<Param>(iSystemTime) | iCallable; }
+
+template <class Param>
+ZCog<Param> sCog_StopAt(ZTime iSystemTime,
+	const ZRef<ZCallable<ZCog<Param>(const ZCog<Param>&,Param)> >& iCallable)
+	{ return sCog_DelayUntil<Param>(iSystemTime) * iCallable; }
+
+template <class Param>
+ZCog<Param> sCog_StartAfter(double iDelay,
+	const ZRef<ZCallable<ZCog<Param>(const ZCog<Param>&,Param)> >iCallable)
+	{ return sCog_DelayFor<Param>(iDelay) | iCallable; }
+
+template <class Param>
+ZCog<Param> sCog_StopAfter(double iDelay,
+	const ZRef<ZCallable<ZCog<Param>(const ZCog<Param>&,Param)> >iCallable)
+	{ return sCog_DelayFor<Param>(iDelay) * iCallable; }
+
+} // namespace ZooLib
+
+#endif // __ZCog_Std__

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2591
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2591&view=rev
Author:   agreen
Date:     2011-10-25 17:17:14 +0000 (Tue, 25 Oct 2011)
Log Message:
-----------
Comment.

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZQ.h

Modified: trunk/zoolib/source/cxx/zoolib/ZQ.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZQ.h	2011-10-25 17:16:58 UTC (rev 2590)
+++ trunk/zoolib/source/cxx/zoolib/ZQ.h	2011-10-25 17:17:14 UTC (rev 2591)
@@ -33,6 +33,7 @@
 #pragma mark -
 #pragma mark * ZQ
 
+// The 'Q' stands for 'Questionable' or 'Queryable'
 // c.f. Haskell's Data.Maybe, Scala's Option.
 
 template <class T, bool Sense = true>

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2581
          http://zoolib.svn.sourceforge.net/zoolib/?rev=2581&view=rev
Author:   agreen
Date:     2011-10-20 21:47:08 +0000 (Thu, 20 Oct 2011)
Log Message:
-----------
Replace ZTween_Scale with a use of ZTween_Applied.
Cache child Tween's durations.

Modified Paths:
--------------
    trunk/zoolib/source/cxx/zoolib/ZTween.h

Modified: trunk/zoolib/source/cxx/zoolib/ZTween.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZTween.h	2011-10-19 23:29:47 UTC (rev 2580)
+++ trunk/zoolib/source/cxx/zoolib/ZTween.h	2011-10-20 21:47:08 UTC (rev 2581)
@@ -86,57 +86,14 @@
 	virtual double Duration() = 0;
 	};
 
-// =================================================================================================
-#pragma mark -
-#pragma mark * ZTween_Indirect
-
 template <class Val>
-class ZTween_Indirect
-:	public ZTween<Val>
+static double sGetDuration(const ZRef<ZTween<Val> >& iTween, ZQ<double>& ioCache)
 	{
-public:
-	ZTween_Indirect()
-		{}
+	if (not ioCache)
+		ioCache = iTween->Duration();
+	return *ioCache;
+	}
 
-	ZTween_Indirect(const ZRef<ZTween<Val> >& iTween)
-	:	fTween(iTween) {}
-
-// From ZTween
-	virtual Val ValAt(double iTime)
-		{
-		if (ZRef<ZTween<Val> > theTween = fTween)
-			return theTween->ValAt(iTime);
-		return Val();
-		}
-
-	virtual double Duration()
-		{
-		if (ZRef<ZTween<Val> > theTween = fTween)
-			return theTween->Duration();
-		return 0;
-		}
-
-	ZRef<ZTween<Val> > Get()
-		{ return fTween; }
-
-	void Set(const ZRef<ZTween<Val> >& iTween)
-		{ fTween = iTween; }
-
-	bool CAS(const ZRef<ZTween<Val> >& iPrior, const ZRef<ZTween<Val> >& iNew)
-		{ return fTween.CAS(iPrior, iNew); }
-
-private:
-	ZRef<ZTween<Val> > fTween;
-	};
-
-template <class Val>
-ZRef<ZTween_Indirect<Val> > sTween_Indirect(const ZRef<ZTween<Val> >& iTween)
-	{ return new ZTween_Indirect<Val>(iTween); }
-
-template <class Val>
-ZRef<ZTween_Indirect<Val> > sTween_Indirect()
-	{ return new ZTween_Indirect<Val>(); }
-
 // =================================================================================================
 #pragma mark -
 #pragma mark * sTween_Either
@@ -156,12 +113,16 @@
 		{ return fCombiner(f0->ValAt(iTime), f1->ValAt(iTime)); }
 
 	virtual double Duration()
-		{ return std::max(f0->Duration(), f1->Duration()); }
+		{ return std::max(sGetDuration(f0, fD0), sGetDuration(f1, fD1)); }
 
 private:
 	Combiner fCombiner;
+
 	const ZRef<ZTween<Val0> > f0;
+	ZQ<double> fD0;
+
 	const ZRef<ZTween<Val1> > f1;
+	ZQ<double> fD1;
 	};
 
 template <class Val0, class Val1>
@@ -235,12 +196,16 @@
 		{ return fCombiner(f0->ValAt(iTime), f1->ValAt(iTime)); }
 
 	virtual double Duration()
-		{ return std::min(f0->Duration(), f1->Duration()); }
+		{ return std::min(sGetDuration(f0, fD0), sGetDuration(f1, fD1)); }
 
 private:
 	Combiner fCombiner;
+
 	const ZRef<ZTween<Val0> > f0;
+	ZQ<double> fD0;
+
 	const ZRef<ZTween<Val1> > f1;
+	ZQ<double> fD1;
 	};
 
 template <class Val0, class Val1>
@@ -290,24 +255,19 @@
 	virtual Val ValAt(double iTime)
 		{
 		if (iTime <= 0)
-			{
 			return f0->ValAt(iTime);
-			}
+		else if (iTime < sGetDuration(f0, fD0))
+			return f0->ValAt(iTime);
 		else
-			{
-			const double duration0 = f0->Duration();
-			if (iTime < duration0)
-				return f0->ValAt(iTime);
-			else
-				return f1->ValAt(iTime - duration0);
-			}
+			return f1->ValAt(iTime - sGetDuration(f0, fD0));
 		}
 
 	virtual double Duration()
-		{ return f0->Duration() + f1->Duration(); }
+		{ return sGetDuration(f0, fD0) + sGetDuration(f1, fD1); }
 
 private:
 	const ZRef<ZTween<Val> > f0, f1;
+	ZQ<double> fD0, fD1;
 	};
 
 template <class Val>
@@ -355,17 +315,21 @@
 // From ZTween
 	virtual Val0 ValAt(double iTime)
 		{
-		const double time1 = iTime / f0->Duration() * f1->Duration();
+		const double time1 = iTime / sGetDuration(f0, fD0) * sGetDuration(f1, fD1);
 		return fCombiner(f0->ValAt(iTime), f1->ValAt(time1));
 		}
 
 	virtual double Duration()
-		{ return f0->Duration(); }
+		{ return sGetDuration(f0, fD0); }
 
 private:
 	Combiner fCombiner;
+
 	const ZRef<ZTween<Val0> > f0;
+	ZQ<double> fD0;
+
 	const ZRef<ZTween<Val1> > f1;
+	ZQ<double> fD1;
 	};
 
 template <class Val0, class Val1>
@@ -418,16 +382,17 @@
 // From ZTween
 	virtual Val ValAt(double iTime)
 		{
-		const double childDuration = fTween->Duration();
+		const double childDuration = sGetDuration(fTween, fTweenDuration);
 		iTime = sMinMax(0.0, iTime, childDuration * fCount);
 		return fTween->ValAt(fmod(iTime, childDuration));
 		}
 
 	virtual double Duration()
-		{ return fCount * fTween->Duration(); }
+		{ return fCount * sGetDuration(fTween, fTweenDuration); }
 
 private:
 	const ZRef<ZTween<Val> > fTween;
+	ZQ<double> fTweenDuration;
 	const size_t fCount;
 	};
 
@@ -456,8 +421,8 @@
 // From ZTween
 	virtual Val ValAt(double iTime)
 		{
-		iTime = sMinMax(0.0, iTime, fDuration);
-		return fTween->ValAt(fmod(iTime, fTween->Duration()));
+		const double theTime = sMinMax(0.0, iTime, fDuration);
+		return fTween->ValAt(fmod(theTime, sGetDuration(fTween, fTweenDuration)));
 		}
 
 	virtual double Duration()
@@ -465,6 +430,7 @@
 
 private:
 	const ZRef<ZTween<Val> > fTween;
+	ZQ<double> fTweenDuration;
 	const double fDuration;
 	};
 
@@ -529,10 +495,11 @@
 		{ return fTween->ValAt(iTime); }
 
 	virtual double Duration()
-		{ return std::min(fAtMost, fTween->Duration()); }
+		{ return std::min(fAtMost, sGetDuration(fTween, fTweenDuration)); }
 
 private:
 	const ZRef<ZTween<Val> > fTween;
+	ZQ<double> fTweenDuration;
 	const double fAtMost;
 	};
 
@@ -563,10 +530,11 @@
 		{ return fTween->ValAt(iTime); }
 
 	virtual double Duration()
-		{ return std::max(fAtLeast, fTween->Duration()); }
+		{ return std::max(fAtLeast, sGetDuration(fTween, fTweenDuration)); }
 
 private:
 	const ZRef<ZTween<Val> > fTween;
+	ZQ<double> fTweenDuration;
 	const double fAtLeast;
 	};
 
@@ -597,10 +565,11 @@
 		{ return fTween->ValAt(iTime - fDelay); }
 
 	virtual double Duration()
-		{ return std::max(0.0, fTween->Duration() + fDelay); }
+		{ return std::max(0.0, sGetDuration(fTween, fTweenDuration) + fDelay); }
 
 private:
 	const ZRef<ZTween<Val> > fTween;
+	ZQ<double> fTweenDuration;
 	const double fDelay;
 	};
 
@@ -632,19 +601,20 @@
 		if (fRate > 0)
 			return fTween->ValAt(iTime / fRate);
 		else
-			return fTween->ValAt(fTween->Duration() + iTime/fRate);
+			return fTween->ValAt(sGetDuration(fTween, fTweenDuration) + iTime/fRate);
 		}
 
 	virtual double Duration()
 		{
 		if (fRate > 0)
-			return fRate * fTween->Duration();
+			return fRate * sGetDuration(fTween, fTweenDuration);
 		else 
-			return -fRate * fTween->Duration();
+			return -fRate * sGetDuration(fTween, fTweenDuration);
 		}
 
 private:
 	const ZRef<ZTween<Val> > fTween;
+	ZQ<double> fTweenDuration;
 	const double fRate;
 	};
 
@@ -671,13 +641,14 @@
 
 // From ZTween
 	virtual Val ValAt(double iTime)
-		{ return fTween->ValAt(iTime / fTween->Duration); }
+		{ return fTween->ValAt(iTime / sGetDuration(fTween, fTweenDuration)); }
 
 	virtual double Duration()
 		{ return 1; }
 
 private:
 	const ZRef<ZTween<Val> > fTween;
+	ZQ<double> fTweenDuration;
 	};
 
 template <class Val>
@@ -727,34 +698,8 @@
 #pragma mark * sTween_Scale
 
 template <class Val>
-class ZTween_Scale
-:	public ZTween<Val>
-	{
-public:
-	ZTween_Scale(const ZRef<ZTween<Val> >& iTween, Val iScale)
-	:	fTween(iTween)
-	,	fScale(iScale)
-		{}
-
-// From ZTween
-	virtual Val ValAt(double iTime)
-		{ return fScale * fTween->ValAt(iTime); }
-
-	virtual double Duration()
-		{ return fTween->Duration(); }
-
-private:
-	const ZRef<ZTween<Val> > fTween;
-	const Val fScale;
-	};
-
-template <class Val>
 ZRef<ZTween<Val> > sTween_Scale(Val iScale, const ZRef<ZTween<Val> >& iTween)
-	{
-	if (iTween)
-		return new ZTween_Scale<Val>(iTween, iScale);
-	return null;
-	}
+	{ return iTween ^ sTween_Const<Val>(iScale); }
 
 // =================================================================================================
 #pragma mark -
@@ -775,10 +720,11 @@
 		{ return fOffset + fTween->ValAt(iTime); }
 
 	virtual double Duration()
-		{ return fTween->Duration(); }
+		{ return sGetDuration(fTween, fTweenDuration); }
 
 private:
 	const ZRef<ZTween<Val> > fTween;
+	ZQ<double> fTweenDuration;
 	const Val fOffset;
 	};
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.