Xapian: Internal Source Documentation: xapian-core: common/pretty.h Source File

00001 
00004 /* Copyright (C) 2010 Olly Betts
00005  *
00006  * This program is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * This program is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
00019  */
00020 
00021 #ifndef XAPIAN_INCLUDED_PRETTY_H
00022 #define XAPIAN_INCLUDED_PRETTY_H
00023 
00024 #include <list>
00025 #include <map>
00026 #include <ostream>
00027 #include <string>
00028 #include <vector>
00029 
00030 #include "xapian/base.h"
00031 #include "xapian/types.h"
00032 
00033 namespace Xapian {
00034 namespace Internal {
00035 
00036 template<class S>
00037 struct PrettyOStream {
00039     S & os;
00040 
00041     PrettyOStream(S & os_) : os(os_) { }
00042 };
00043 
00044 struct Literal {
00045     const char * _lit;
00046     Literal(const char * lit) : _lit(lit) { }
00047     Literal(const std::string & s) : _lit(s.c_str()) { }
00048 };
00049 
00050 }
00051 }
00052 
00053 using Xapian::Internal::PrettyOStream;
00054 using Xapian::Internal::Literal;
00055 
00057 template<class S, class T>
00058 inline PrettyOStream<S> &
00059 operator<<(PrettyOStream<S> &ps, const T & t)
00060 {
00061     ps.os << t;
00062     return ps;
00063 }
00064 
00072 template<class S>
00073 inline PrettyOStream<S> &
00074 operator<<(PrettyOStream<S> &ps, const Literal & t)
00075 {
00076     ps.os << t._lit;
00077     return ps;
00078 }
00079 
00080 template<class S, class T>
00081 inline PrettyOStream<S> &
00082 operator<<(PrettyOStream<S> &ps, const T * t)
00083 {
00084     if (!t) {
00085         ps.os << "NULL";
00086         return ps;
00087     }
00088     ps.os << '&';
00089     return ps << *t;
00090 }
00091 
00092 template<class S, class T>
00093 inline PrettyOStream<S> &
00094 operator<<(PrettyOStream<S> &ps, const T ** t)
00095 {
00096     ps.os << (void*)t;
00097     return ps;
00098 }
00099 
00100 template<class S>
00101 inline PrettyOStream<S> &
00102 operator<<(PrettyOStream<S> &ps, const void * t)
00103 {
00104     ps.os << "(void*)" << t;
00105     return ps;
00106 }
00107 
00108 // FIXME: We probably don't want to inline this, but need to arrange to
00109 // put it somewhere sane out-of-line.
00110 inline void write_ch(std::ostream & os, unsigned char ch)
00111 {
00112     if (ch < 32 || ch >= 127) {
00113         os << '\\';
00114         if (ch >= 7 && ch <= 13) {
00115             os << "abtnvfr"[ch - 7];
00116         } else {
00117             os << char('0' | (ch >> 6));
00118             os << char('0' | ((ch >> 3) & 7));
00119             os << char('0' | (ch & 7));
00120         }
00121     } else if (ch == '\\') {
00122         os << "\\\\";
00123     } else if (ch == '"') {
00124         os << "\\\"";
00125     } else {
00126         os << ch;
00127     }
00128 }
00129 
00130 template<class S>
00131 inline PrettyOStream<S> &
00132 operator<<(PrettyOStream<S> &ps, const char * str)
00133 {
00134     ps.os << '"';
00135     while (*str) {
00136         write_ch(ps.os, *str++);
00137     }
00138     ps.os << '"';
00139     return ps;
00140 }
00141 
00142 template<class S>
00143 inline PrettyOStream<S> &
00144 operator<<(PrettyOStream<S> &ps, const std::string & str)
00145 {
00146     ps.os << '"';
00147     for (std::string::const_iterator i = str.begin(); i != str.end(); ++i) {
00148         write_ch(ps.os, *i);
00149     }
00150     ps.os << '"';
00151     return ps;
00152 }
00153 
00154 template<class S>
00155 inline PrettyOStream<S> &
00156 operator<<(PrettyOStream<S> &ps, std::string &)
00157 {
00158     ps.os << "std::string&";
00159     return ps;
00160 }
00161 
00162 template<class S>
00163 inline PrettyOStream<S> &
00164 operator<<(PrettyOStream<S> &ps, std::string *)
00165 {
00166     ps.os << "std::string*";
00167     return ps;
00168 }
00169 
00170 template<class S>
00171 inline PrettyOStream<S> &
00172 operator<<(PrettyOStream<S> &ps, unsigned char ch)
00173 {
00174     ps.os << '\'';
00175     if (ch < 32 || ch >= 127) {
00176         ps.os << '\\';
00177         if (ch >= 7 && ch <= 13) {
00178             ps.os << "abtnvfr"[ch - 7];
00179         } else if (ch == '\0') {
00180             ps.os << "\\0";
00181         } else {
00182             ps.os << "0123456789abcdef"[ch >> 4];
00183             ps.os << "0123456789abcdef"[ch & 0x0f];
00184         }
00185     } else if (ch == '\\') {
00186         ps.os << "\\\\";
00187     } else if (ch == '\'') {
00188         ps.os << "\\'";
00189     } else {
00190         ps.os << ch;
00191     }
00192     ps.os << '\'';
00193     return ps;
00194 }
00195 
00196 template<class S>
00197 inline PrettyOStream<S> &
00198 operator<<(PrettyOStream<S> &ps, bool b)
00199 {
00200     ps.os << (b ? "true" : "false");
00201     return ps;
00202 }
00203 
00204 /*
00205 template<class S>
00206 inline PrettyOStream<S> &
00207 operator<<(PrettyOStream<S> &ps, bool &)
00208 {
00209     ps.os << "bool&";
00210     return ps;
00211 }
00212 */
00213 
00214 template<class S>
00215 inline PrettyOStream<S> &
00216 operator<<(PrettyOStream<S> &ps, Xapian::termcount * p)
00217 {
00218     ps.os << "(Xapian::termcount*)" << (void*)p;
00219     return ps;
00220 }
00221 
00222 template<class S, typename T>
00223 inline PrettyOStream<S> &
00224 operator<<(PrettyOStream<S> &ps, std::list<T> &) {
00225     ps.os << "std::list&";
00226     return ps;
00227 }
00228 
00229 template<class S, typename T>
00230 inline PrettyOStream<S> &
00231 operator<<(PrettyOStream<S> &ps, const std::list<T> &) {
00232     ps.os << "std::list";
00233     // FIXME: could show first up to N elements.
00234     return ps;
00235 }
00236 
00237 template<class S, typename K, typename V>
00238 inline PrettyOStream<S> &
00239 operator<<(PrettyOStream<S> &ps, std::map<K, V> *) {
00240     ps.os << "std::map*";
00241     return ps;
00242 }
00243 
00244 template<class S, typename K, typename V>
00245 inline PrettyOStream<S> &
00246 operator<<(PrettyOStream<S> &ps, std::map<K, V> &) {
00247     ps.os << "std::map&";
00248     return ps;
00249 }
00250 
00251 template<class S, typename K, typename V>
00252 inline PrettyOStream<S> &
00253 operator<<(PrettyOStream<S> &ps, const std::map<K, V> & m) {
00254     ps.os << "std::map(" << m.size() << ')';
00255     // FIXME: could show first up to N elements.
00256     return ps;
00257 }
00258 
00259 template<class S, typename T>
00260 inline PrettyOStream<S> &
00261 operator<<(PrettyOStream<S> &ps, const std::vector<T> & v) {
00262     ps.os << "std::vector(" << v.size() << ')';
00263     // FIXME: could show first up to N elements.
00264     return ps;
00265 }
00266 
00267 namespace Xapian {
00268     class ExpandDecider;
00269     class MatchDecider;
00270     class Registry;
00271     class Weight;
00272     namespace Internal {
00273         class ExpandStats;
00274         class ExpandWeight;
00275     }
00276 }
00277 
00278 class BrassCursor;
00279 class BrassDatabase;
00280 class BrassTable;
00281 class ChertCursor;
00282 class ChertDatabase;
00283 class ChertTable;
00284 class FlintCursor;
00285 class FlintDatabase;
00286 class FlintTable;
00287 class FlintValueTable;
00288 class FlintRecordTable;
00289 
00290 #define XAPIAN_PRETTY_AS_CLASSNAME(C)\
00291 template<class S>\
00292 inline PrettyOStream<S> &\
00293 operator<<(PrettyOStream<S> &ps, const C &) {\
00294     ps.os << #C;\
00295     return ps;\
00296 }
00297 
00298 XAPIAN_PRETTY_AS_CLASSNAME(Xapian::ExpandDecider)
00299 XAPIAN_PRETTY_AS_CLASSNAME(Xapian::MatchDecider)
00300 XAPIAN_PRETTY_AS_CLASSNAME(Xapian::Registry)
00301 XAPIAN_PRETTY_AS_CLASSNAME(Xapian::Weight)
00302 XAPIAN_PRETTY_AS_CLASSNAME(BrassCursor);
00303 XAPIAN_PRETTY_AS_CLASSNAME(BrassDatabase);
00304 XAPIAN_PRETTY_AS_CLASSNAME(BrassTable);
00305 XAPIAN_PRETTY_AS_CLASSNAME(ChertCursor);
00306 XAPIAN_PRETTY_AS_CLASSNAME(ChertDatabase);
00307 XAPIAN_PRETTY_AS_CLASSNAME(ChertTable);
00308 XAPIAN_PRETTY_AS_CLASSNAME(FlintCursor);
00309 XAPIAN_PRETTY_AS_CLASSNAME(FlintDatabase);
00310 XAPIAN_PRETTY_AS_CLASSNAME(FlintTable);
00311 XAPIAN_PRETTY_AS_CLASSNAME(FlintValueTable);
00312 XAPIAN_PRETTY_AS_CLASSNAME(FlintRecordTable);
00313 
00314 template<class S>
00315 inline PrettyOStream<S> &
00316 operator<<(PrettyOStream<S> &ps, const Xapian::Weight *p) {
00317     ps.os << "(Xapian:Weight*)" << (void*)p;
00318     return ps;
00319 }
00320 
00321 template<class S>
00322 inline PrettyOStream<S> &
00323 operator<<(PrettyOStream<S> &ps, const Xapian::Internal::ExpandStats &) {
00324     ps.os << "Xapian:Internal::ExpandStats";
00325     return ps;
00326 }
00327 
00328 template<class S>
00329 inline PrettyOStream<S> &
00330 operator<<(PrettyOStream<S> &ps, const Xapian::Internal::ExpandWeight &) {
00331     ps.os << "Xapian:Internal::ExpandWeight";
00332     return ps;
00333 }
00334 
00335 class RemoteConnection;
00336 
00337 template<class S>
00338 inline PrettyOStream<S> &
00339 operator<<(PrettyOStream<S> &ps, const RemoteConnection &) {
00340     ps.os << "RemoteConnection";
00341     return ps;
00342 }
00343 
00344 #include "common/database.h"
00345 
00346 template<class S>
00347 inline PrettyOStream<S> &
00348 operator<<(PrettyOStream<S> &ps, const Xapian::Database::Internal *p) {
00349     ps.os << "(Database::Internal*)" << (void*)p;
00350     return ps;
00351 }
00352 
00353 class FlintCursor;
00354 
00355 template<class S>
00356 inline PrettyOStream<S> &
00357 operator<<(PrettyOStream<S> &ps, const FlintCursor *) {
00358     ps.os << "FlintCursor*";
00359     return ps;
00360 }
00361 
00362 template<class S, class T>
00363 inline PrettyOStream<S> &
00364 operator<<(PrettyOStream<S> &ps, Xapian::Internal::RefCntPtr<const T> t) {
00365     ps.os << "RefCntPtr->";
00366     return ps << t;
00367 }
00368 
00369 template<class S, typename T>
00370 inline PrettyOStream<S> &
00371 operator|(PrettyOStream<S> &ps, const T & t) {
00372     ps.os << ", ";
00373     return ps << t;
00374 }
00375 
00376 #endif // XAPIAN_INCLUDED_PRETTY_H