arma_boost Namespace Reference
[Format_wrap]

namespace for functions and classes which partially emulate Boost functionality More...


Classes

class  format
class  basic_format
struct  format_metaprog
struct  format_metaprog< basic_format< T1, T2 > >

Functions

template<typename T2 >
basic_format< format, T2 > operator% (const format &X, const T2 &arg)
template<typename T1 , typename T2 , typename T3 >
basic_format< basic_format< T1,
T2 >, T3 > 
operator% (const basic_format< T1, T2 > &X, const T3 &arg)
template<typename T2 >
std::string str (const basic_format< format, T2 > &X)
template<typename T2 , typename T3 >
std::string str (const basic_format< basic_format< format, T2 >, T3 > &X)
template<typename T2 , typename T3 , typename T4 >
std::string str (const basic_format< basic_format< basic_format< format, T2 >, T3 >, T4 > &X)
template<typename T2 , typename T3 , typename T4 , typename T5 >
std::string str (const basic_format< basic_format< basic_format< basic_format< format, T2 >, T3 >, T4 >, T5 > &X)
template<typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
std::string str (const basic_format< basic_format< basic_format< basic_format< basic_format< format, T2 >, T3 >, T4 >, T5 >, T6 > &X)
template<typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
std::string str (const basic_format< basic_format< basic_format< basic_format< basic_format< basic_format< format, T2 >, T3 >, T4 >, T5 >, T6 >, T7 > &X)
template<typename T1 , typename T2 >
std::string str (const basic_format< T1, T2 > &X)
template<typename T1 , typename T2 >
std::ostream & operator<< (std::ostream &o, const basic_format< T1, T2 > &X)


Detailed Description

namespace for functions and classes which partially emulate Boost functionality


Function Documentation

template<typename T2 >
basic_format< format, T2 > arma_boost::operator% ( const format &  X,
const T2 &  arg 
) [inline]

Definition at line 76 of file format_wrap.hpp.

00077       {
00078       return basic_format< format, T2 >(X, arg);
00079       }

template<typename T1 , typename T2 , typename T3 >
basic_format< basic_format<T1,T2>, T3 > arma_boost::operator% ( const basic_format< T1, T2 > &  X,
const T3 &  arg 
) [inline]

Definition at line 86 of file format_wrap.hpp.

00087       {
00088       return basic_format< basic_format<T1,T2>, T3 >(X, arg);
00089       }

template<typename T2 >
std::string arma_boost::str ( const basic_format< format, T2 > &  X  )  [inline]

Definition at line 96 of file format_wrap.hpp.

References arma_boost::basic_format< T1, T2 >::A, and arma_boost::basic_format< T1, T2 >::B.

Referenced by operator<<().

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       }

template<typename T2 , typename T3 >
std::string arma_boost::str ( const basic_format< basic_format< format, T2 >, T3 > &  X  )  [inline]

Definition at line 128 of file format_wrap.hpp.

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       }

template<typename T2 , typename T3 , typename T4 >
std::string arma_boost::str ( const basic_format< basic_format< basic_format< format, T2 >, T3 >, T4 > &  X  )  [inline]

Definition at line 160 of file format_wrap.hpp.

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       }

template<typename T2 , typename T3 , typename T4 , typename T5 >
std::string arma_boost::str ( const basic_format< basic_format< basic_format< basic_format< format, T2 >, T3 >, T4 >, T5 > &  X  )  [inline]

Definition at line 192 of file format_wrap.hpp.

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       }

template<typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
std::string arma_boost::str ( const basic_format< basic_format< basic_format< basic_format< basic_format< format, T2 >, T3 >, T4 >, T5 >, T6 > &  X  )  [inline]

Definition at line 224 of file format_wrap.hpp.

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       }

template<typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
std::string arma_boost::str ( const basic_format< basic_format< basic_format< basic_format< basic_format< basic_format< format, T2 >, T3 >, T4 >, T5 >, T6 >, T7 > &  X  )  [inline]

Definition at line 256 of file format_wrap.hpp.

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       }

template<typename T1 , typename T2 >
std::string arma_boost::str ( const basic_format< T1, T2 > &  X  )  [inline]

Definition at line 322 of file format_wrap.hpp.

References arma_boost::basic_format< T1, T2 >::A.

Referenced by arma_check().

00323       {
00324       return format_metaprog< basic_format<T1,T2> >::get_fmt(X.A);
00325       }

template<typename T1 , typename T2 >
std::ostream& arma_boost::operator<< ( std::ostream &  o,
const basic_format< T1, T2 > &  X 
) [inline]

Definition at line 332 of file format_wrap.hpp.

References str().

00333       {
00334       o << str(X);
00335       return o;
00336       }