src/texstream.h

   1 // -*- C++ -*-
   2 /**
   3  * \file texstream.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Enrico Forestieri
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #ifndef LYX_TEXSTREAM_H
  13 #define LYX_TEXSTREAM_H
  14
  15 #include "support/docstream.h"
  16 #include "support/unique_ptr.h"
  17
  18 namespace lyx {
  19
  20 class TexRow;
  21 struct TexString;
  22
  23
  24 /** Wrapper class for odocstream.
  25     This class is used to automatically count the lines of the exported latex
  26     code.
  27   */
  28
  29 class otexrowstream {
  30 public:
  31         ///
  32         explicit otexrowstream(odocstream & os);
  33         /// defaulted
  34         ~otexrowstream();
  35         ///
  36         odocstream & os() { return os_; }
  37         ///
  38         TexRow & texrow() { return *texrow_; }
  39         ///
  40         unique_ptr<TexRow> releaseTexRow();
  41         ///
  42         void put(char_type const & c);
  43         ///
  44         void append(TexString ts);
  45 private:
  46         ///
  47         odocstream & os_;
  48         ///
  49         unique_ptr<TexRow> texrow_;
  50 };
  51
  52 ///
  53 otexrowstream & operator<<(otexrowstream &, odocstream_manip);
  54 ///
  55 otexrowstream & operator<<(otexrowstream &, TexString);
  56 ///
  57 otexrowstream & operator<<(otexrowstream &, docstring const &);
  58 ///
  59 otexrowstream & operator<<(otexrowstream &, std::string const &);
  60 ///
  61 otexrowstream & operator<<(otexrowstream &, char const *);
  62 ///
  63 otexrowstream & operator<<(otexrowstream &, char);
  64 ///
  65 template <typename Type>
  66 otexrowstream & operator<<(otexrowstream & ots, Type value);
  67
  68
  69 /** Subclass for otexrowstream.
  70     This class is used to ensure that no blank lines may be inadvertently output.
  71     To this end, use the special variables "breakln" and "safebreakln" as if
  72     they were iomanip's to ensure that the next output will start at the
  73     beginning of a line. Using "breakln", a '\n' char will be output if needed,
  74     while using "safebreakln", "%\n" will be output if needed.
  75     The class also records the last output character and can tell whether
  76     a paragraph break was just output.
  77   */
  78
  79 class otexstream : public otexrowstream {
  80 public:
  81         ///
  82         explicit otexstream(odocstream & os)
  83                 : otexrowstream(os), canbreakline_(false),
  84                   protectspace_(false), terminate_command_(false),
  85                   parbreak_(true), blankline_(true), lastchar_(0) {}
  86         ///
  87         void put(char_type const & c);
  88         ///
  89         void append(TexString ts);
  90         ///
  91         void canBreakLine(bool breakline) { canbreakline_ = breakline; }
  92         ///
  93         bool canBreakLine() const { return canbreakline_; }
  94         ///
  95         void protectSpace(bool protectspace) { protectspace_ = protectspace; }
  96         ///
  97         bool protectSpace() const { return protectspace_; }
  98         ///
  99         void terminateCommand(bool terminate) { terminate_command_ = terminate; }
 100         ///
 101         bool terminateCommand() const { return terminate_command_; }
 102         ///
 103         void lastChar(char_type const & c)
 104         {
 105                 parbreak_ = (!canbreakline_ && c == '\n');
 106                 blankline_ = ((!canbreakline_ && c == ' ') || c == '\n');
 107                 canbreakline_ = (c != '\n');
 108                 lastchar_ = c;
 109         }
 110         ///
 111         char_type lastChar() const { return lastchar_; }
 112         ///
 113         bool afterParbreak() const { return parbreak_; }
 114         ///
 115         bool blankLine() const { return blankline_; }
 116 private:
 117         ///
 118         bool canbreakline_;
 119         ///
 120         bool protectspace_;
 121         ///
 122         bool terminate_command_;
 123         ///
 124         bool parbreak_;
 125         ///
 126         bool blankline_;
 127         ///
 128         char_type lastchar_;
 129 };
 130
 131
 132 /// because we need to pass ods_ to the base class
 133 struct otexstringstream_helper { odocstringstream ods_; };
 134
 135 /// otexstringstream : a odocstringstream with tex/row correspondence
 136 class otexstringstream : otexstringstream_helper, public otexstream {
 137 public:
 138         otexstringstream() : otexstringstream_helper(), otexstream(ods_) {}
 139         ///
 140         docstring str() const { return ods_.str(); }
 141         ///
 142         size_t length();
 143         ///
 144         bool empty() { return 0 == length(); }
 145         /// move-returns the contents and reset the texstream
 146         TexString release();
 147 };
 148
 149
 150 /// Helper structs for breaking a line
 151 struct BreakLine {
 152         char n;
 153 };
 154
 155 struct SafeBreakLine {
 156         char n;
 157 };
 158
 159 /// Helper structs for terminating a command
 160 struct TerminateCommand {
 161         char n;
 162 };
 163
 164 extern BreakLine breakln;
 165 extern SafeBreakLine safebreakln;
 166 extern TerminateCommand termcmd;
 167
 168 ///
 169 otexstream & operator<<(otexstream &, BreakLine);
 170 ///
 171 otexstream & operator<<(otexstream &, SafeBreakLine);
 172 ///
 173 otexstream & operator<<(otexstream &, TerminateCommand);
 174 ///
 175 otexstream & operator<<(otexstream &, odocstream_manip);
 176 ///
 177 otexstream & operator<<(otexstream &, TexString);
 178 ///
 179 otexstream & operator<<(otexstream &, docstring const &);
 180 ///
 181 otexstream & operator<<(otexstream &, std::string const &);
 182 ///
 183 otexstream & operator<<(otexstream &, char const *);
 184 ///
 185 otexstream & operator<<(otexstream &, char);
 186 ///
 187 template <typename Type>
 188 otexstream & operator<<(otexstream & ots, Type value);
 189
 190
 191 } // namespace lyx
 192
 193 #endif