src/support/docstream.h

   1 // -*- C++ -*-
   2 /**
   3  * \file docstream.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Georg Baum
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #ifndef LYX_DOCSTREAM_H
  13 #define LYX_DOCSTREAM_H
  14
  15 #include "TexRow.h"
  16 #include "support/docstring.h"
  17
  18 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
  19 // Ugly workaround for MSVC10 STL bug:
  20 // std::numpunct has a hardcoded dllimport in definition, but we wanna it with 32 bit
  21 // so we can't import it and must define it but then the compiler complains.
  22 #include "support/numpunct_lyx_char_type.h"
  23 #endif
  24
  25 #include <fstream>
  26 #include <sstream>
  27
  28 namespace lyx {
  29
  30 class iconv_codecvt_facet_exception : public std::exception {
  31 public:
  32         virtual ~iconv_codecvt_facet_exception() throw() {}
  33         virtual const char * what() const throw();
  34 };
  35
  36 /// Base class for UCS4 input streams
  37 typedef std::basic_istream<char_type> idocstream;
  38
  39 /** Base class for UCS4 output streams.
  40     If you want to output a single UCS4 character, use \code
  41     os.put(c);
  42     \endcode, not \code
  43     os << c;
  44     \endcode . The latter will not output the character, but the code point
  45     as number. This is because we can't overload operator<< (our character
  46     type is not a real type but a typedef). Narrow characters of type char
  47     can be output as usual.
  48  */
  49 typedef std::basic_ostream<char_type> odocstream;
  50
  51 /// File stream for reading UTF8-encoded files with automatic conversion to
  52 /// UCS4.
  53 class ifdocstream : public std::basic_ifstream<char_type> {
  54         typedef std::basic_ifstream<char_type> base;
  55 public:
  56         ifdocstream();
  57         explicit ifdocstream(const char* s,
  58                 std::ios_base::openmode mode = std::ios_base::in,
  59                 std::string const & encoding = "UTF-8");
  60         ~ifdocstream() {}
  61 };
  62
  63 /// File stream for writing files in 8bit encoding \p encoding with automatic
  64 /// conversion from UCS4.
  65
  66 class ofdocstream : public std::basic_ofstream<char_type> {
  67         typedef std::basic_ofstream<char_type> base;
  68 public:
  69         ofdocstream();
  70         explicit ofdocstream(const char* s,
  71                 std::ios_base::openmode mode = std::ios_base::out|std::ios_base::trunc,
  72                 std::string const & encoding = "UTF-8");
  73         ~ofdocstream() {}
  74         ///
  75         void reset(std::string const & encoding);
  76 };
  77
  78
  79
  80 /// UCS4 input stringstream
  81 typedef std::basic_istringstream<char_type> idocstringstream;
  82
  83 /// UCS4 output stringstream
  84 typedef std::basic_ostringstream<char_type> odocstringstream;
  85
  86 /** Wrapper class for odocstream.
  87     This class is used to automatically count the lines of the exported latex
  88     code and also to ensure that no blank lines may be inadvertently output.
  89     To this end, use the special variables "breakln" and "safebreakln" as if
  90     they were iomanip's to ensure that the next output will start at the
  91     beginning of a line. Using "breakln", a '\n' char will be output if needed,
  92     while using "safebreakln", "%\n" will be output if needed.
  93   */
  94
  95 class otexstream {
  96 public:
  97         ///
  98         otexstream(odocstream & os, TexRow & texrow)
  99                 : os_(os), texrow_(texrow),
 100                   canbreakline_(false), protectspace_(false) {}
 101         ///
 102         odocstream & os() { return os_; }
 103         ///
 104         TexRow & texrow() { return texrow_; }
 105         ///
 106         void put(char_type const & c);
 107         ///
 108         void canBreakLine(bool breakline) { canbreakline_ = breakline; }
 109         ///
 110         bool canBreakLine() const { return canbreakline_; }
 111         ///
 112         void protectSpace(bool protectspace) { protectspace_ = protectspace; }
 113         ///
 114         bool protectSpace() const { return protectspace_; }
 115 private:
 116         ///
 117         odocstream & os_;
 118         ///
 119         TexRow & texrow_;
 120         ///
 121         bool canbreakline_;
 122         ///
 123         bool protectspace_;
 124 };
 125
 126 /// Helper structs for breaking a line
 127 struct BreakLine {
 128         char n;
 129 };
 130
 131 struct SafeBreakLine {
 132         char n;
 133 };
 134
 135 extern BreakLine breakln;
 136 extern SafeBreakLine safebreakln;
 137
 138 ///
 139 otexstream & operator<<(otexstream &, BreakLine);
 140 ///
 141 otexstream & operator<<(otexstream &, SafeBreakLine);
 142 ///
 143 otexstream & operator<<(otexstream &, docstring const &);
 144 ///
 145 otexstream & operator<<(otexstream &, char const *);
 146 ///
 147 otexstream & operator<<(otexstream &, char);
 148 ///
 149 template <typename Type>
 150 otexstream & operator<<(otexstream & ots, Type value);
 151
 152 /// Helper struct for changing stream encoding
 153 struct SetEnc {
 154         SetEnc(std::string const & e) : encoding(e) {}
 155         std::string encoding;
 156 };
 157
 158 /// Helper function for changing stream encoding
 159 SetEnc setEncoding(std::string const & encoding);
 160
 161 /** Change the encoding of \p os to \p e.encoding.
 162     \p e.encoding must be a valid iconv name of an 8bit encoding.
 163     This does nothing if the stream is not a file stream, since only
 164     file streams do have an associated 8bit encoding.
 165     Usage: \code
 166     os << setEncoding("ISO-8859-1");
 167     \endcode
 168  */
 169 odocstream & operator<<(odocstream & os, SetEnc e);
 170 idocstream & operator<<(idocstream & os, SetEnc e);
 171
 172 }
 173
 174 #endif