00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
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