Index: src/Common/utility.h
===================================================================
--- src/Common/utility.h	(revision a7741435e0c633ce848e2268e9ac69fac9d35686)
+++ src/Common/utility.h	(revision 4a9ccc35f7b5fed64bf53eee245fc9caa37f687d)
@@ -252,8 +252,8 @@
 
 template< typename T >
-struct reverseIterate_t {
+struct reverse_iterate_t {
 	T& ref;
 
-	reverseIterate_t( T & ref ) : ref(ref) {}
+	reverse_iterate_t( T & ref ) : ref(ref) {}
 
 	typedef typename T::reverse_iterator iterator;
@@ -263,8 +263,44 @@
 
 template< typename T >
-reverseIterate_t< T > reverseIterate( T & ref ) {
-	return reverseIterate_t< T >( ref );
-}
-
+reverse_iterate_t< T > reverseIterate( T & ref ) {
+	return reverse_iterate_t< T >( ref );
+}
+
+// -----------------------------------------------------------------------------
+// Helper struct and function to support
+// for ( val : group_iterate( container1, container2, ... ) ) {}
+// syntax to have a for each that iterates multiple containers of the same length
+// TODO: update to use variadic arguments
+
+template< typename T1, typename T2 >
+struct group_iterate_t {
+	group_iterate_t( const T1 & v1, const T2 & v2 ) : args(v1, v2) {
+		assertf(v1.size() == v2.size(), "group iteration requires containers of the same size.");
+	};
+
+	struct iterator {
+		typedef std::tuple<typename T1::value_type, typename T2::value_type> value_type;
+		typedef typename T1::iterator T1Iter;
+		typedef typename T2::iterator T2Iter;
+		typedef std::tuple<T1Iter, T2Iter> IterTuple;
+		IterTuple it;
+		iterator( T1Iter i1, T2Iter i2 ) : it( i1, i2 ) {}
+		iterator operator++() {
+			return iterator( ++std::get<0>(it), ++std::get<1>(it) );
+		}
+		bool operator!=( const iterator &other ) const { return it != other.it; }
+		value_type operator*() const { return std::make_tuple( *std::get<0>(it), *std::get<1>(it) ); }
+	};
+	iterator begin() { return iterator( std::get<0>(args).begin(), std::get<1>(args).begin() ); }
+	iterator end() { return iterator( std::get<0>(args).end(), std::get<1>(args).end() ); }
+
+private:
+	std::tuple<T1, T2> args;
+};
+
+template< typename... Args >
+group_iterate_t<Args...> group_iterate( const Args &... args ) {
+	return group_iterate_t<Args...>(args...);
+}
 #endif // _UTILITY_H