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 stringstream
  84 typedef std::basic_ostringstream<char_type> odocstringstream;
  85
  86 /// UCS4 output manipulator
  87 typedef odocstream & (*odocstream_manip)(odocstream &);
  88
  89 /** Wrapper class for odocstream.
  90     This class is used to automatically count the lines of the exported latex
  91     code and also to ensure that no blank lines may be inadvertently output.
  92     To this end, use the special variables "breakln" and "safebreakln" as if
  93     they were iomanip's to ensure that the next output will start at the
  94     beginning of a line. Using "breakln", a '\n' char will be output if needed,
  95     while using "safebreakln", "%\n" will be output if needed.
  96   */
  97
  98 class otexstream {
  99 public:
 100         ///
 101         otexstream(odocstream & os, TexRow & texrow)
 102                 : os_(os), texrow_(texrow),
 103                   canbreakline_(false), protectspace_(false) {}
 104         ///
 105         odocstream & os() { return os_; }
 106         ///
 107         TexRow & texrow() { return texrow_; }
 108         ///
 109         void put(char_type const & c);
 110         ///
 111         void canBreakLine(bool breakline) { canbreakline_ = breakline; }
 112         ///
 113         bool canBreakLine() const { return canbreakline_; }
 114         ///
 115         void protectSpace(bool protectspace) { protectspace_ = protectspace; }
 116         ///
 117         bool protectSpace() const { return protectspace_; }
 118 private:
 119         ///
 120         odocstream & os_;
 121         ///
 122         TexRow & texrow_;
 123         ///
 124         bool canbreakline_;
 125         ///
 126         bool protectspace_;
 127 };
 128
 129 /// Helper structs for breaking a line
 130 struct BreakLine {
 131         char n;
 132 };
 133
 134 struct SafeBreakLine {
 135         char n;
 136 };
 137
 138 extern BreakLine breakln;
 139 extern SafeBreakLine safebreakln;
 140
 141 ///
 142 otexstream & operator<<(otexstream &, BreakLine);
 143 ///
 144 otexstream & operator<<(otexstream &, SafeBreakLine);
 145 ///
 146 otexstream & operator<<(otexstream &, odocstream_manip);
 147 ///
 148 otexstream & operator<<(otexstream &, docstring const &);
 149 ///
 150 otexstream & operator<<(otexstream &, char const *);
 151 ///
 152 otexstream & operator<<(otexstream &, char);
 153 ///
 154 template <typename Type>
 155 otexstream & operator<<(otexstream & ots, Type value);
 156
 157 /// Helper struct for changing stream encoding
 158 struct SetEnc {
 159         SetEnc(std::string const & e) : encoding(e) {}
 160         std::string encoding;
 161 };
 162
 163 /// Helper function for changing stream encoding
 164 SetEnc setEncoding(std::string const & encoding);
 165
 166 /** Change the encoding of \p os to \p e.encoding.
 167     \p e.encoding must be a valid iconv name of an 8bit encoding.
 168     This does nothing if the stream is not a file stream, since only
 169     file streams do have an associated 8bit encoding.
 170     Usage: \code
 171     os << setEncoding("ISO-8859-1");
 172     \endcode
 173  */
 174 odocstream & operator<<(odocstream & os, SetEnc e);
 175 idocstream & operator<<(idocstream & os, SetEnc e);
 176
 177 }
 178
 179 #endif