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 if USE_WCHAR_T is not defined. This is because we can't overload
  46     operator<< (our character type is not always a real type but sometimes a
  47     typedef). Narrow characters of type char 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 manipulator
  84 typedef odocstream & (*odocstream_manip)(odocstream &);
  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     The class also records the last output character and can tell whether
  94     a paragraph break was just output.
  95   */
  96
  97 class otexstream {
  98 public:
  99         ///
 100         otexstream(odocstream & os, TexRow & texrow)
 101                 : os_(os), texrow_(texrow), canbreakline_(false),
 102                   protectspace_(false), parbreak_(true), lastchar_(0) {}
 103         ///
 104         odocstream & os() { return os_; }
 105         ///
 106         TexRow & texrow() { return texrow_; }
 107         ///
 108         void put(char_type const & c);
 109         ///
 110         void canBreakLine(bool breakline) { canbreakline_ = breakline; }
 111         ///
 112         bool canBreakLine() const { return canbreakline_; }
 113         ///
 114         void protectSpace(bool protectspace) { protectspace_ = protectspace; }
 115         ///
 116         bool protectSpace() const { return protectspace_; }
 117         ///
 118         void lastChar(char_type const & c)
 119         {
 120                 parbreak_ = (!canbreakline_ && c == '\n');
 121                 canbreakline_ = (c != '\n');
 122                 lastchar_ = c;
 123         }
 124         ///
 125         char_type lastChar() const { return lastchar_; }
 126         ///
 127         bool afterParbreak() const { return parbreak_; }
 128 private:
 129         ///
 130         odocstream & os_;
 131         ///
 132         TexRow & texrow_;
 133         ///
 134         bool canbreakline_;
 135         ///
 136         bool protectspace_;
 137         ///
 138         bool parbreak_;
 139         ///
 140         char_type lastchar_;
 141 };
 142
 143 /// Helper structs for breaking a line
 144 struct BreakLine {
 145         char n;
 146 };
 147
 148 struct SafeBreakLine {
 149         char n;
 150 };
 151
 152 extern BreakLine breakln;
 153 extern SafeBreakLine safebreakln;
 154
 155 ///
 156 otexstream & operator<<(otexstream &, BreakLine);
 157 ///
 158 otexstream & operator<<(otexstream &, SafeBreakLine);
 159 ///
 160 otexstream & operator<<(otexstream &, odocstream_manip);
 161 ///
 162 otexstream & operator<<(otexstream &, docstring const &);
 163 ///
 164 otexstream & operator<<(otexstream &, std::string const &);
 165 ///
 166 otexstream & operator<<(otexstream &, char const *);
 167 ///
 168 otexstream & operator<<(otexstream &, char);
 169 ///
 170 template <typename Type>
 171 otexstream & operator<<(otexstream & ots, Type value);
 172
 173 /// Helper struct for changing stream encoding
 174 struct SetEnc {
 175         SetEnc(std::string const & e) : encoding(e) {}
 176         std::string encoding;
 177 };
 178
 179 /// Helper function for changing stream encoding
 180 SetEnc setEncoding(std::string const & encoding);
 181
 182 /** Change the encoding of \p os to \p e.encoding.
 183     \p e.encoding must be a valid iconv name of an 8bit encoding.
 184     This does nothing if the stream is not a file stream, since only
 185     file streams do have an associated 8bit encoding.
 186     Usage: \code
 187     os << setEncoding("ISO-8859-1");
 188     \endcode
 189  */
 190 odocstream & operator<<(odocstream & os, SetEnc e);
 191 idocstream & operator<<(idocstream & os, SetEnc e);
 192
 193 }
 194
 195 #endif