ArrayConversions_UnitTests.cpp

Go to the documentation of this file.
00001 
00002 #include "Teuchos_ArrayConversions.hpp"
00003 #include "Teuchos_implicit_cast.hpp"
00004 #include "Array_UnitTest_helpers.hpp"
00005 #include "ArrayConversions_UnitTest_helpers.hpp"
00006 #include "TestClasses.hpp"
00007 
00008 namespace {
00009 
00010 
00011 using ArrayUnitTestHelpers::n;
00012 using ArrayConversionsUnitTestHelpers::generateArrayRcp;
00013 using ArrayConversionsUnitTestHelpers::generateArrayRcpGen;
00014 using ArrayConversionsUnitTestHelpers::testArrayViewInput;
00015 using ArrayConversionsUnitTestHelpers::testArrayViewOutput;
00016 using Teuchos::arrayPtrConv;
00017 using Teuchos::arrayRcpConv;
00018 using Teuchos::arrayViewPtrConv;
00019 using Teuchos::arrayViewRcpConv;
00020 using Teuchos::Array;
00021 using Teuchos::ArrayView;
00022 using Teuchos::Ptr;
00023 using Teuchos::RCP;
00024 using Teuchos::rcp;
00025 using Teuchos::as;
00026 using Teuchos::implicit_ptr_cast;
00027 
00028 
00029 // Verify generateArrayRcp works correctly
00030 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, generateArrayRcp, T )
00031 {
00032   const Array<RCP<T> > a_in = generateArrayRcp<T>(n);
00033   TEST_EQUALITY_CONST( as<Teuchos_Ordinal>(a_in.size()), n );
00034   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00035     TEST_EQUALITY_CONST( Teuchos::is_null(a_in[i]), false );
00036     TEST_EQUALITY_CONST( *a_in[i], as<T>(i) );
00037   }
00038 }
00039 
00040 
00041 // Verify testArrayViewInput works correctly
00042 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, testArrayViewInput, T )  
00043 {
00044   typedef Teuchos::ScalarTraits<T> ST;
00045   const Array<RCP<T> > a_data = generateArrayRcp<T>(n);
00046   Array<Ptr<const T> > a_in(n);
00047   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00048     a_in[i] = a_data[i].ptr();
00049   }
00050   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00051     TEST_EQUALITY_CONST( Teuchos::is_null(a_in[i]), false );
00052   }
00053   T a_out = testArrayViewInput<T>(a_in);
00054   TEST_EQUALITY_CONST( a_out, as<T>(n*(n-1)/2) );
00055 }
00056 
00057 
00058 // Verify testArrayViewOutput works correctly
00059 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, testArrayViewOutput, T )  
00060 {
00061   typedef Teuchos::ScalarTraits<T> ST;
00062   const Array<RCP<T> > a_data = generateArrayRcp<T>(n);
00063   Array<Ptr<T> > a_out;
00064   a_out.reserve(n);
00065   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00066     *a_data[i] = ST::zero();
00067     a_out.push_back( a_data[i].ptr() );
00068   }
00069   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00070     TEST_EQUALITY_CONST( Teuchos::is_null(a_out[i]), false );
00071   }
00072   testArrayViewOutput<T>(a_out);
00073   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00074     TEST_EQUALITY_CONST( *a_out[i], as<T>(i) );
00075   }
00076 
00077 }
00078 
00079 
00080 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_RcpNonconst_to_PtrConst, T ) 
00081 {
00082   const Array<RCP<T> > a_in = generateArrayRcp<T>(n);
00083   const Array<Ptr<const T> > a_out = arrayPtrConv<const T>(a_in);
00084   TEST_EQUALITY( a_out.size(), a_in.size() );
00085   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00086     TEST_EQUALITY( a_out[i].get(), a_in[i].get() );
00087     TEST_EQUALITY( *a_out[i], *a_in[i] );
00088   }
00089 }
00090 
00091 
00092 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_RcpNonconst_to_PtrNonconst, T ) 
00093 {
00094   const Array<RCP<T> > a_in = generateArrayRcp<T>(n);
00095   const Array<Ptr<T> > a_out = arrayPtrConv<T>(a_in);
00096   TEST_EQUALITY( a_out.size(), a_in.size() );
00097   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00098     TEST_EQUALITY( a_out[i].get(), a_in[i].get() );
00099     TEST_EQUALITY( *a_out[i], *a_in[i] );
00100   }
00101 }
00102 
00103 
00104 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_PtrNonconst_to_PtrNonconst, T ) 
00105 {
00106   const Array<RCP<T> > a_in = generateArrayRcp<T>(n);
00107   const Array<Ptr<T> > a1_out = arrayPtrConv<T>(a_in);
00108   const Array<Ptr<T> > a2_out = arrayPtrConv<T>(a1_out());
00109   TEST_COMPARE_ARRAYS( a2_out, a1_out );
00110 }
00111 
00112 
00113 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_PtrNonconst_to_PtrConst, T ) 
00114 {
00115   const Array<RCP<T> > a_in = generateArrayRcp<T>(n);
00116   const Array<Ptr<T> > a1_out = arrayPtrConv<T>(a_in);
00117   const Array<Ptr<const T> > a2_out = arrayPtrConv<const T>(a1_out());
00118   TEST_COMPARE_ARRAYS( a2_out, a1_out );
00119 }
00120 
00121 
00122 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_PtrConst_to_PtrConst, T ) 
00123 {
00124   const Array<RCP<T> > a_in = generateArrayRcp<T>(n);
00125   const Array<Ptr<const T> > a1_out = arrayPtrConv<const T>(a_in);
00126   const Array<Ptr<const T> > a2_out = arrayPtrConv<const T>(a1_out());
00127   TEST_COMPARE_ARRAYS( a2_out, a1_out );
00128 }
00129 
00130 
00131 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_PassConst, T ) 
00132 {
00133   Array<RCP<T> > a_in = generateArrayRcp<T>(n);
00134   T a = testArrayViewInput<T>(arrayPtrConv<const T>(a_in));
00135   T a_exact = as<T>(n*(n-1)/2);
00136   TEST_EQUALITY( a, a_exact );
00137 }
00138 
00139 
00140 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayPtrConv_PassNonconst, T ) 
00141 {
00142   typedef Teuchos::ScalarTraits<T> ST;
00143   Array<RCP<T> > a_out = generateArrayRcp<T>(n);
00144   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00145     *a_out[i] = ST::zero();
00146   }
00147   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00148     TEST_EQUALITY_CONST( *a_out[i], ST::zero() );
00149   }
00150   testArrayViewOutput<T>(arrayPtrConv<T>(a_out));
00151   TEST_EQUALITY_CONST( as<Teuchos_Ordinal>(a_out.size()), n );
00152   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00153     TEST_EQUALITY_CONST( *a_out[i], as<T>(i) );
00154   }
00155 }
00156 
00157 
00158 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayRcpConv_RcpNonconst_to_RcpNonconst, T ) 
00159 {
00160   const Array<RCP<T> > a_in = generateArrayRcp<T>(n);
00161   const Array<RCP<T> > a1_out = arrayRcpConv<T>(a_in);
00162   TEST_COMPARE_ARRAYS( a1_out, a_in );
00163 }
00164 
00165 
00166 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayRcpConv_RcpNonconst_to_RcpConst, T ) 
00167 {
00168   const Array<RCP<T> > a_in = generateArrayRcp<T>(n);
00169   const Array<RCP<const T> > a1_out = arrayRcpConv<const T>(a_in);
00170   TEST_COMPARE_ARRAYS( a1_out, a_in );
00171 }
00172 
00173 
00174 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayRcpConv_RcpConst_to_RcpConst, T ) 
00175 {
00176   const Array<RCP<T> > a_in = generateArrayRcp<T>(n);
00177   const Array<RCP<const T> > a1_out = arrayRcpConv<const T>(a_in);
00178   const Array<RCP<const T> > a2_out = arrayRcpConv<const T>(a1_out);
00179   TEST_COMPARE_ARRAYS( a2_out, a1_out );
00180 }
00181 
00182 
00183 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayConstPtrConstCast_nonconst_to_const,
00184   T ) 
00185 {
00186   Array<RCP<T> > a_rcp = generateArrayRcp<T>(n);
00187   Array<Ptr<T> > a_ptr = arrayPtrConv<T>(a_rcp);
00188   const ArrayView<const Ptr<T> > av_ptr_nonconst = a_ptr();
00189   const ArrayView<const Ptr<const T> > av_ptr_const =
00190     Teuchos::arrayConstPtrConstCast(av_ptr_nonconst);
00191   TEST_COMPARE_ARRAYS( av_ptr_nonconst, av_ptr_const );
00192 }
00193 
00194 
00195 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayConstPtrConstCast_const_to_const,
00196   T ) 
00197 {
00198   Array<RCP<T> > a_rcp = generateArrayRcp<T>(n);
00199   Array<Ptr<const T> > a_ptr = arrayPtrConv<const T>(a_rcp);
00200   const ArrayView<const Ptr<const T> > av_ptr_const1 = a_ptr();
00201   const ArrayView<const Ptr<const T> > av_ptr_const2 =
00202     Teuchos::arrayConstPtrConstCast(av_ptr_const1);
00203   TEST_COMPARE_ARRAYS( av_ptr_const1, av_ptr_const2 );
00204 }
00205 
00206 
00207 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayConstRcpConstCast_nonconst_to_const,
00208   T ) 
00209 {
00210   Array<RCP<T> > a_rcp = generateArrayRcp<T>(n);
00211   const ArrayView<const RCP<T> > av_rcp_nonconst = a_rcp();
00212   const ArrayView<const RCP<const T> > av_rcp_const =
00213     Teuchos::arrayConstRcpConstCast(av_rcp_nonconst);
00214   TEST_COMPARE_ARRAYS( av_rcp_nonconst, av_rcp_const );
00215 }
00216 
00217 
00218 TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL( ArrayConversions, arrayConstRcpConstCast_const_to_const,
00219   T ) 
00220 {
00221   Array<RCP<T> > a_rcp_orig = generateArrayRcp<T>(n);
00222   Array<RCP<const T> > a_rcp = arrayRcpConv<const T>(a_rcp_orig);
00223   const ArrayView<const RCP<const T> > av_rcp_const1 = a_rcp();
00224   const ArrayView<const RCP<const T> > av_rcp_const2 =
00225     Teuchos::arrayConstRcpConstCast(av_rcp_const1);
00226   TEST_COMPARE_ARRAYS( av_rcp_const1, av_rcp_const2 );
00227 }
00228 
00229 
00230 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00231 
00232 #  define DEBUG_UNIT_TEST_GROUP( T )
00233 
00234 #else // HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00235 
00236 #  define DEBUG_UNIT_TEST_GROUP( T )
00237 
00238 #endif // HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
00239 
00240 #define UNIT_TEST_GROUP( T ) \
00241   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, generateArrayRcp, T ) \
00242   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, testArrayViewInput, T ) \
00243   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, testArrayViewOutput, T ) \
00244   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_RcpNonconst_to_PtrConst, T ) \
00245   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_RcpNonconst_to_PtrNonconst, T ) \
00246   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_PtrNonconst_to_PtrNonconst, T ) \
00247   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_PtrNonconst_to_PtrConst, T ) \
00248   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_PtrConst_to_PtrConst, T ) \
00249   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayRcpConv_RcpConst_to_RcpConst, T ) \
00250   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_PassConst, T ) \
00251   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayPtrConv_PassNonconst, T ) \
00252   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayRcpConv_RcpNonconst_to_RcpNonconst, T ) \
00253   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayRcpConv_RcpNonconst_to_RcpConst, T ) \
00254   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayConstPtrConstCast_nonconst_to_const, T ) \
00255   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayConstPtrConstCast_const_to_const, T ) \
00256   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayConstRcpConstCast_nonconst_to_const, T ) \
00257   TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( ArrayConversions, arrayConstRcpConstCast_const_to_const, T ) \
00258   DEBUG_UNIT_TEST_GROUP( T )
00259 
00260 
00261 UNIT_TEST_GROUP(Teuchos_Ordinal)
00262 UNIT_TEST_GROUP(float)
00263 UNIT_TEST_GROUP(double)
00264 
00265 
00266 
00267 TEUCHOS_UNIT_TEST( ArrayConversions, arrayPtrConv_RcpNonconstDerived_to_PtrNonconstBase) 
00268 {
00269   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00270   const Array<Ptr<A> > a_out = arrayPtrConv<A>(a_in);
00271   TEST_EQUALITY( a_out.size(), a_in.size() );
00272   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00273     TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );
00274   }
00275 }
00276 
00277 
00278 TEUCHOS_UNIT_TEST( ArrayConversions, arrayPtrConv_RcpNonconstDerived_to_PtrConstBase) 
00279 {
00280   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00281   const Array<Ptr<const A> > a_out = arrayPtrConv<const A>(a_in);
00282   TEST_EQUALITY( a_out.size(), a_in.size() );
00283   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00284     TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<const A>(&*a_in[i]) );
00285   }
00286 }
00287 
00288 
00289 TEUCHOS_UNIT_TEST( ArrayConversions, arrayPtrConv_RcpConstDerived_to_PtrConstBase) 
00290 {
00291   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00292   const Array<RCP<const C> > a1_out = arrayRcpConv<const C>(a_in);
00293   const Array<Ptr<const A> > a2_out = arrayPtrConv<const A>(a1_out);
00294   TEST_EQUALITY( a2_out.size(), a_in.size() );
00295   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00296     TEST_EQUALITY( &*a2_out[i], implicit_ptr_cast<const A>(&*a_in[i]) );
00297   }
00298 }
00299 
00300 
00301 TEUCHOS_UNIT_TEST( ArrayConversions, arrayRcpConv_RcpNonconstDerived_to_RcpNonconstBase) 
00302 {
00303   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00304   const Array<RCP<A> > a_out = arrayRcpConv<A>(a_in);
00305   TEST_EQUALITY( a_out.size(), a_in.size() );
00306   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00307     TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );
00308   }
00309 }
00310 
00311 
00312 TEUCHOS_UNIT_TEST( ArrayConversions, arrayRcpConv_RcpNonconstDerived_to_RcpConstBase) 
00313 {
00314   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00315   const Array<RCP<const A> > a_out = arrayRcpConv<const A>(a_in);
00316   TEST_EQUALITY( a_out.size(), a_in.size() );
00317   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00318     TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );
00319   }
00320 }
00321 
00322 
00323 TEUCHOS_UNIT_TEST( ArrayConversions, arrayRcpConv_RcpConstDerived_to_RcpConstBase) 
00324 {
00325   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00326   const Array<RCP<const C> > a1_out = arrayRcpConv<const C>(a_in);
00327   const Array<RCP<const A> > a2_out = arrayRcpConv<const A>(a1_out);
00328   TEST_EQUALITY( a2_out.size(), a_in.size() );
00329   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00330     TEST_EQUALITY( &*a2_out[i], implicit_ptr_cast<A>(&*a_in[i]) );
00331   }
00332 }
00333 
00334 
00335 TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewPtrConv_RcpNonconstDerived_to_PtrNonconstBase) 
00336 {
00337   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00338   Array<Ptr<A> > a_out(n);
00339   arrayViewPtrConv(a_in, a_out());
00340   TEST_EQUALITY( a_out.size(), a_in.size() );
00341   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00342     TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );
00343   }
00344 }
00345 
00346 
00347 TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewPtrConv_RcpNonconstDerived_to_PtrConstBase) 
00348 {
00349   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00350   Array<Ptr<const A> > a_out(n);
00351   arrayViewPtrConv(a_in, a_out());
00352   TEST_EQUALITY( a_out.size(), a_in.size() );
00353   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00354     TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<const A>(&*a_in[i]) );
00355   }
00356 }
00357 
00358 
00359 TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewPtrConv_RcpConstDerived_to_PtrConstBase) 
00360 {
00361   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00362   Array<RCP<const C> > a1_out(n);
00363   arrayViewRcpConv(a_in, a1_out());
00364   Array<Ptr<const A> > a2_out(n);
00365   arrayViewPtrConv(a1_out, a2_out());
00366   TEST_EQUALITY( a2_out.size(), a_in.size() );
00367   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00368     TEST_EQUALITY( &*a2_out[i], implicit_ptr_cast<const A>(&*a_in[i]) );
00369   }
00370 }
00371 
00372 
00373 TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewRcpConv_RcpNonconstDerived_to_RcpNonconstBase) 
00374 {
00375   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00376   Array<RCP<A> > a_out(n);
00377   arrayViewRcpConv(a_in, a_out());
00378   TEST_EQUALITY( a_out.size(), a_in.size() );
00379   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00380     TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );
00381   }
00382 }
00383 
00384 
00385 TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewRcpConv_RcpNonconstDerived_to_RcpConstBase) 
00386 {
00387   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00388   Array<RCP<const A> > a_out(n);
00389   arrayViewRcpConv(a_in, a_out());
00390   TEST_EQUALITY( a_out.size(), a_in.size() );
00391   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00392     TEST_EQUALITY( &*a_out[i], implicit_ptr_cast<A>(&*a_in[i]) );
00393   }
00394 }
00395 
00396 
00397 TEUCHOS_UNIT_TEST( ArrayConversions, arrayViewRcpConv_RcpConstDerived_to_RcpConstBase) 
00398 {
00399   const Array<RCP<C> > a_in = generateArrayRcpGen<C>(n);
00400   Array<RCP<const C> > a1_out(n);
00401   arrayViewRcpConv(a_in, a1_out());
00402   Array<RCP<const A> > a2_out(n);
00403   arrayViewRcpConv(a1_out, a2_out());
00404   TEST_EQUALITY( a2_out.size(), a_in.size() );
00405   for (Teuchos_Ordinal i=0 ; i<n ; ++i) {
00406     TEST_EQUALITY( &*a2_out[i], implicit_ptr_cast<A>(&*a_in[i]) );
00407   }
00408 }
00409 
00410 
00411 } // namespace
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on Tue Oct 20 10:13:58 2009 for Teuchos Package Browser (Single Doxygen Collection) by  doxygen 1.6.1