format_wrap.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2009 NICTA
00002 // 
00003 // Authors:
00004 // - Conrad Sanderson (conradsand at ieee dot org)
00005 // 
00006 // This file is part of the Armadillo C++ library.
00007 // It is provided without any warranty of fitness
00008 // for any purpose. You can redistribute this file
00009 // and/or modify it under the terms of the GNU
00010 // Lesser General Public License (LGPL) as published
00011 // by the Free Software Foundation, either version 3
00012 // of the License or (at your option) any later version.
00013 // (see http://www.opensource.org/licenses for more info)
00014 
00015 
00016 //! \addtogroup format_wrap
00017 //! @{
00018 
00019 
00020 //! \namespace arma_boost namespace for functions and classes which partially emulate Boost functionality 
00021 namespace arma_boost
00022   {
00023   
00024   #ifdef ARMA_USE_BOOST
00025     using boost::format;
00026     using boost::basic_format;
00027     using boost::str;
00028   #else
00029     
00030     class format
00031       {
00032       public:
00033     
00034       format(const char* in_fmt)
00035         : A(in_fmt)
00036         {
00037         }
00038     
00039       format(const std::string& in_fmt)
00040         : A(in_fmt)
00041         {
00042         }
00043     
00044     
00045       const std::string A;
00046     
00047       private:
00048       format();
00049       };
00050     
00051     
00052     
00053     template<typename T1, typename T2>
00054     class basic_format
00055       {
00056       public:
00057     
00058       basic_format(const T1& in_A, const T2& in_B)
00059         : A(in_A)
00060         , B(in_B)
00061         {
00062         }
00063     
00064       const T1& A;
00065       const T2& B;
00066     
00067       private:
00068       basic_format();
00069       };
00070     
00071     
00072     
00073     template<typename T2>
00074     inline
00075     basic_format< format, T2 >
00076     operator% (const format& X, const T2& arg)
00077       {
00078       return basic_format< format, T2 >(X, arg);
00079       }
00080     
00081     
00082     
00083     template<typename T1, typename T2, typename T3>
00084     inline
00085     basic_format< basic_format<T1,T2>, T3 >
00086     operator% (const basic_format<T1,T2>& X, const T3& arg)
00087       {
00088       return basic_format< basic_format<T1,T2>, T3 >(X, arg);
00089       }
00090     
00091     
00092     
00093     template<typename T2>
00094     inline
00095     std::string
00096     str(const basic_format< format, T2>& X)
00097       {
00098       int data_size = 1024;
00099       int reqd_size = data_size;
00100     
00101       std::string out;
00102     
00103       do
00104         {
00105         char* data = new char[data_size];
00106         reqd_size = snprintf(data, data_size, X.A.A.c_str(), X.B);
00107     
00108         if(reqd_size < 0)
00109           break;
00110     
00111         if(reqd_size < data_size)
00112           out = data;
00113         else
00114           data_size *= 2;
00115     
00116         delete[] data;
00117     
00118         } while(reqd_size >= data_size);
00119     
00120       return out;
00121       }
00122     
00123     
00124     
00125     template<typename T2, typename T3>
00126     inline
00127     std::string
00128     str(const basic_format< basic_format< format, T2>, T3>& X)
00129       {
00130       int data_size = 1024;
00131       int reqd_size = data_size;
00132     
00133       std::string out;
00134     
00135       do
00136         {
00137         char* data = new char[data_size];
00138         reqd_size = snprintf(data, data_size, X.A.A.A.c_str(), X.A.B, X.B);
00139     
00140         if(reqd_size < 0)
00141           break;
00142     
00143         if(reqd_size < data_size)
00144           out = data;
00145         else
00146           data_size *= 2;
00147     
00148         delete[] data;
00149     
00150         } while(reqd_size >= data_size);
00151     
00152       return out;
00153       }
00154     
00155     
00156     
00157     template<typename T2, typename T3, typename T4>
00158     inline
00159     std::string
00160     str(const basic_format< basic_format< basic_format< format, T2>, T3>, T4>& X)
00161       {
00162       int data_size = 1024;
00163       int reqd_size = data_size;
00164     
00165       std::string out;
00166     
00167       do
00168         {
00169         char* data = new char[data_size];
00170         reqd_size = snprintf(data, data_size, X.A.A.A.A.c_str(), X.A.A.B, X.A.B, X.B);
00171     
00172         if(reqd_size < 0)
00173           break;
00174     
00175         if(reqd_size < data_size)
00176           out = data;
00177         else
00178           data_size *= 2;
00179     
00180         delete[] data;
00181     
00182         } while(reqd_size >= data_size);
00183     
00184       return out;
00185       }
00186     
00187     
00188     
00189     template<typename T2, typename T3, typename T4, typename T5>
00190     inline
00191     std::string
00192     str(const basic_format< basic_format< basic_format< basic_format< format, T2>, T3>, T4>, T5>& X)
00193       {
00194       int data_size = 1024;
00195       int reqd_size = data_size;
00196     
00197       std::string out;
00198     
00199       do
00200         {
00201         char* data = new char[data_size];
00202         reqd_size = snprintf(data, data_size, X.A.A.A.A.A.c_str(), X.A.A.A.B, X.A.A.B, X.A.B, X.B);
00203     
00204         if(reqd_size < 0)
00205           break;
00206     
00207         if(reqd_size < data_size)
00208           out = data;
00209         else
00210           data_size *= 2;
00211     
00212         delete[] data;
00213     
00214         } while(reqd_size >= data_size);
00215     
00216       return out;
00217       }
00218     
00219     
00220     
00221     template<typename T2, typename T3, typename T4, typename T5, typename T6>
00222     inline
00223     std::string
00224     str(const basic_format< basic_format< basic_format< basic_format< basic_format< format, T2>, T3>, T4>, T5>, T6>& X)
00225       {
00226       int data_size = 1024;
00227       int reqd_size = data_size;
00228     
00229       std::string out;
00230     
00231       do
00232         {
00233         char* data = new char[data_size];
00234         reqd_size = snprintf(data, data_size, X.A.A.A.A.A.A.c_str(), X.A.A.A.A.B, X.A.A.A.B, X.A.A.B, X.A.B, X.B);
00235     
00236         if(reqd_size < 0)
00237           break;
00238     
00239         if(reqd_size < data_size)
00240           out = data;
00241         else
00242           data_size *= 2;
00243     
00244         delete[] data;
00245     
00246         } while(reqd_size >= data_size);
00247     
00248       return out;
00249       }
00250     
00251     
00252     
00253     template<typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
00254     inline
00255     std::string
00256     str(const basic_format< basic_format< basic_format< basic_format< basic_format< basic_format< format, T2>, T3>, T4>, T5>, T6>, T7>& X)
00257       {
00258       int data_size = 1024;
00259       int reqd_size = data_size;
00260     
00261       std::string out;
00262     
00263       do
00264         {
00265         char* data = new char[data_size];
00266         reqd_size = snprintf(data, data_size, X.A.A.A.A.A.A.A.c_str(), X.A.A.A.A.A.B, X.A.A.A.A.B, X.A.A.A.B, X.A.A.B, X.A.B, X.B);
00267     
00268         if(reqd_size < 0)
00269           break;
00270     
00271         if(reqd_size < data_size)
00272           out = data;
00273         else
00274           data_size *= 2;
00275     
00276         delete[] data;
00277     
00278         } while(reqd_size >= data_size);
00279     
00280       return out;
00281       }
00282     
00283     
00284     
00285     template<typename T1>
00286     struct format_metaprog
00287       {
00288       static const u32 depth = 0;
00289     
00290       inline
00291       static  
00292       const std::string&
00293       get_fmt(const T1& X)
00294         {
00295         return X.A;
00296         }
00297       };
00298     
00299     
00300     
00301     template<>
00302     template<typename T1, typename T2>
00303     struct format_metaprog< basic_format<T1,T2> >
00304       {
00305       static const u32 depth = 1 + format_metaprog<T1>::depth;
00306     
00307       inline
00308       static
00309       const std::string&
00310       get_fmt(const T1& X)
00311         {
00312         return format_metaprog<T1>::get_fmt(X.A);
00313         }
00314     
00315       };
00316     
00317     
00318     
00319     template<typename T1, typename T2>
00320     inline
00321     std::string
00322     str(const basic_format<T1,T2>& X)
00323       {
00324       return format_metaprog< basic_format<T1,T2> >::get_fmt(X.A);
00325       }
00326     
00327     
00328     
00329     template<typename T1, typename T2>
00330     inline
00331     std::ostream&
00332     operator<< (std::ostream& o, const basic_format<T1,T2>& X)
00333       {
00334       o << str(X);
00335       return o;
00336       }
00337         
00338         
00339   #endif
00340   
00341   }
00342 
00343 //! @}