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

int arma_snprintf (char *out, size_t size, const char *fmt,...)
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

int arma_boost::arma_snprintf ( char *  out,
size_t  size,
const char *  fmt,
  ... 
) [inline]

Definition at line 44 of file format_wrap.hpp.

Referenced by str().

00045         {
00046         size_t i;
00047         
00048         for(i=0; i<size; ++i)
00049           {
00050           out[i] = fmt[i];
00051           if(fmt[i] == char(0))
00052             break;
00053           }
00054         
00055         if(size > 0)
00056           out[size-1] = char(0);
00057         
00058         return int(i);
00059         }

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

Definition at line 109 of file format_wrap.hpp.

00110       {
00111       return basic_format< format, T2 >(X, arg);
00112       }

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 119 of file format_wrap.hpp.

00120       {
00121       return basic_format< basic_format<T1,T2>, T3 >(X, arg);
00122       }

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

Definition at line 129 of file format_wrap.hpp.

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

Referenced by operator<<().

00130       {
00131       char  local_buffer[1024];
00132       char* buffer = local_buffer;
00133       
00134       int buffer_size   = 1024;
00135       int required_size = buffer_size;
00136    
00137       bool using_local_buffer = true;
00138       
00139       std::string out;
00140       
00141       do
00142         {
00143         if(using_local_buffer == false)
00144           {
00145           buffer = new char[buffer_size];
00146           }
00147         
00148         required_size = arma_snprintf(buffer, buffer_size, X.A.A.c_str(), X.B);
00149         
00150         if(required_size < buffer_size)
00151           {
00152           if(required_size > 0)
00153             {
00154             out = buffer;
00155             }
00156           }
00157         else
00158           {
00159           buffer_size *= 2;
00160           }
00161         
00162         if(using_local_buffer == true)
00163           {
00164           using_local_buffer = false;
00165           }
00166         else
00167           {
00168           delete[] buffer;
00169           }
00170         
00171         } while( (required_size >= buffer_size) );
00172 
00173       return out;
00174       }

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

Definition at line 181 of file format_wrap.hpp.

References arma_snprintf().

00182       {
00183       char  local_buffer[1024];
00184       char* buffer = local_buffer;
00185       
00186       int buffer_size   = 1024;
00187       int required_size = buffer_size;
00188    
00189       bool using_local_buffer = true;
00190       
00191       std::string out;
00192       
00193       do
00194         {
00195         if(using_local_buffer == false)
00196           {
00197           buffer = new char[buffer_size];
00198           }
00199         
00200         required_size = arma_snprintf(buffer, buffer_size, X.A.A.A.c_str(), X.A.B, X.B);
00201         
00202         if(required_size < buffer_size)
00203           {
00204           if(required_size > 0)
00205             {
00206             out = buffer;
00207             }
00208           }
00209         else
00210           {
00211           buffer_size *= 2;
00212           }
00213         
00214         if(using_local_buffer == true)
00215           {
00216           using_local_buffer = false;
00217           }
00218         else
00219           {
00220           delete[] buffer;
00221           }
00222         
00223         } while( (required_size >= buffer_size) );
00224 
00225       return out;
00226       }

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 233 of file format_wrap.hpp.

References arma_snprintf().

00234       {
00235       char  local_buffer[1024];
00236       char* buffer = local_buffer;
00237       
00238       int buffer_size   = 1024;
00239       int required_size = buffer_size;
00240    
00241       bool using_local_buffer = true;
00242       
00243       std::string out;
00244       
00245       do
00246         {
00247         if(using_local_buffer == false)
00248           {
00249           buffer = new char[buffer_size];
00250           }
00251         
00252         required_size = arma_snprintf(buffer, buffer_size, X.A.A.A.A.c_str(), X.A.A.B, X.A.B, X.B);
00253         
00254         if(required_size < buffer_size)
00255           {
00256           if(required_size > 0)
00257             {
00258             out = buffer;
00259             }
00260           }
00261         else
00262           {
00263           buffer_size *= 2;
00264           }
00265         
00266         if(using_local_buffer == true)
00267           {
00268           using_local_buffer = false;
00269           }
00270         else
00271           {
00272           delete[] buffer;
00273           }
00274         
00275         } while( (required_size >= buffer_size) );
00276 
00277       return out;
00278       }

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 285 of file format_wrap.hpp.

References arma_snprintf().

00286       {
00287       char  local_buffer[1024];
00288       char* buffer = local_buffer;
00289       
00290       int buffer_size   = 1024;
00291       int required_size = buffer_size;
00292    
00293       bool using_local_buffer = true;
00294       
00295       std::string out;
00296       
00297       do
00298         {
00299         if(using_local_buffer == false)
00300           {
00301           buffer = new char[buffer_size];
00302           }
00303         
00304         required_size = arma_snprintf(buffer, buffer_size, X.A.A.A.A.A.c_str(), X.A.A.A.B, X.A.A.B, X.A.B, X.B);
00305         
00306         if(required_size < buffer_size)
00307           {
00308           if(required_size > 0)
00309             {
00310             out = buffer;
00311             }
00312           }
00313         else
00314           {
00315           buffer_size *= 2;
00316           }
00317         
00318         if(using_local_buffer == true)
00319           {
00320           using_local_buffer = false;
00321           }
00322         else
00323           {
00324           delete[] buffer;
00325           }
00326         
00327         } while( (required_size >= buffer_size) );
00328 
00329       return out;
00330       }

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 337 of file format_wrap.hpp.

References arma_snprintf().

00338       {
00339       char  local_buffer[1024];
00340       char* buffer = local_buffer;
00341       
00342       int buffer_size   = 1024;
00343       int required_size = buffer_size;
00344    
00345       bool using_local_buffer = true;
00346       
00347       std::string out;
00348       
00349       do
00350         {
00351         if(using_local_buffer == false)
00352           {
00353           buffer = new char[buffer_size];
00354           }
00355         
00356         required_size = arma_snprintf(buffer, buffer_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);
00357         
00358         if(required_size < buffer_size)
00359           {
00360           if(required_size > 0)
00361             {
00362             out = buffer;
00363             }
00364           }
00365         else
00366           {
00367           buffer_size *= 2;
00368           }
00369         
00370         if(using_local_buffer == true)
00371           {
00372           using_local_buffer = false;
00373           }
00374         else
00375           {
00376           delete[] buffer;
00377           }
00378         
00379         } while( (required_size >= buffer_size) );
00380 
00381       return out;
00382       }

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 389 of file format_wrap.hpp.

References arma_snprintf().

00390       {
00391       char  local_buffer[1024];
00392       char* buffer = local_buffer;
00393       
00394       int buffer_size   = 1024;
00395       int required_size = buffer_size;
00396    
00397       bool using_local_buffer = true;
00398       
00399       std::string out;
00400       
00401       do
00402         {
00403         if(using_local_buffer == false)
00404           {
00405           buffer = new char[buffer_size];
00406           }
00407         
00408         required_size = arma_snprintf(buffer, buffer_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);
00409         
00410         if(required_size < buffer_size)
00411           {
00412           if(required_size > 0)
00413             {
00414             out = buffer;
00415             }
00416           }
00417         else
00418           {
00419           buffer_size *= 2;
00420           }
00421         
00422         if(using_local_buffer == true)
00423           {
00424           using_local_buffer = false;
00425           }
00426         else
00427           {
00428           delete[] buffer;
00429           }
00430         
00431         } while( (required_size >= buffer_size) );
00432 
00433       return out;
00434       }

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

Definition at line 475 of file format_wrap.hpp.

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

Referenced by arma_check().

00476       {
00477       return format_metaprog< basic_format<T1,T2> >::get_fmt(X.A);
00478       }

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

Definition at line 485 of file format_wrap.hpp.

References str().

00486       {
00487       o << str(X);
00488       return o;
00489       }