src/curses/strbuffer.h

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2016 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #ifndef NCMPCPP_STRBUFFER_H
  22 #define NCMPCPP_STRBUFFER_H
  23
  24 #include <boost/lexical_cast.hpp>
  25 #include <map>
  26 #include "window.h"
  27
  28 namespace NC {
  29
  30 /// Buffer template class that stores text
  31 /// along with its properties (colors/formatting).
  32 template <typename CharT> class BasicBuffer
  33 {
  34         struct Property
  35         {
  36                 enum class Type { Color, Format };
  37
  38                 Property(NC::Color color_, size_t id_)
  39                 : m_type(Type::Color), m_color(std::move(color_)), m_id(id_) { }
  40                 Property(NC::Format format_, size_t id_)
  41                 : m_type(Type::Format), m_format(format_), m_id(id_) { }
  42
  43                 size_t id() const { return m_id; }
  44
  45                 template <typename OutputStreamT>
  46                 friend OutputStreamT &operator<<(OutputStreamT &os, const Property &p)
  47                 {
  48                         switch (p.m_type)
  49                         {
  50                                 case Type::Color:
  51                                         os << p.m_color;
  52                                         break;
  53                                 case Type::Format:
  54                                         os << p.m_format;
  55                                         break;
  56                         }
  57                         return os;
  58                 }
  59
  60         private:
  61                 Type m_type;
  62                 Color m_color;
  63                 Format m_format;
  64                 size_t m_id;
  65         };
  66
  67 public:
  68         typedef std::basic_string<CharT> StringType;
  69         typedef std::multimap<size_t, Property> Properties;
  70
  71         const StringType &str() const { return m_string; }
  72         const Properties &properties() const { return m_properties; }
  73
  74         template <typename PropertyT>
  75         void addProperty(size_t position, PropertyT &&property, size_t id = -1)
  76         {
  77                 assert(position <= m_string.size());
  78                 m_properties.emplace(position, Property(std::forward<PropertyT>(property), id));
  79         }
  80
  81         void removeProperties(size_t id = -1)
  82         {
  83                 auto it = m_properties.begin();
  84                 while (it != m_properties.end())
  85                 {
  86                         if (it->second.id() == id)
  87                                 m_properties.erase(it++);
  88                         else
  89                                 ++it;
  90                 }
  91         }
  92
  93         bool empty() const
  94         {
  95                 return m_string.empty() && m_properties.empty();
  96         }
  97
  98         void clear()
  99         {
 100                 m_string.clear();
 101                 m_properties.clear();
 102         }
 103
 104         BasicBuffer<CharT> &operator<<(int n)
 105         {
 106                 m_string += boost::lexical_cast<StringType>(n);
 107                 return *this;
 108         }
 109
 110         BasicBuffer<CharT> &operator<<(long int n)
 111         {
 112                 m_string += boost::lexical_cast<StringType>(n);
 113                 return *this;
 114         }
 115
 116         BasicBuffer<CharT> &operator<<(unsigned int n)
 117         {
 118                 m_string += boost::lexical_cast<StringType>(n);
 119                 return *this;
 120         }
 121
 122         BasicBuffer<CharT> &operator<<(unsigned long int n)
 123         {
 124                 m_string += boost::lexical_cast<StringType>(n);
 125                 return *this;
 126         }
 127
 128         BasicBuffer<CharT> &operator<<(CharT c)
 129         {
 130                 m_string += c;
 131                 return *this;
 132         }
 133
 134         BasicBuffer<CharT> &operator<<(const CharT *s)
 135         {
 136                 m_string += s;
 137                 return *this;
 138         }
 139
 140         BasicBuffer<CharT> &operator<<(const StringType &s)
 141         {
 142                 m_string += s;
 143                 return *this;
 144         }
 145
 146         BasicBuffer<CharT> &operator<<(Color color)
 147         {
 148                 addProperty(m_string.size(), color);
 149                 return *this;
 150         }
 151
 152         BasicBuffer<CharT> &operator<<(Format format)
 153         {
 154                 addProperty(m_string.size(), format);
 155                 return *this;
 156         }
 157
 158         // static variadic initializer. used instead of a proper constructor because
 159         // it's too polymorphic and would end up invoked as a copy/move constructor.
 160         template <typename... Args>
 161         static BasicBuffer init(Args&&... args)
 162         {
 163                 BasicBuffer result;
 164                 result.construct(std::forward<Args>(args)...);
 165                 return result;
 166         }
 167
 168 private:
 169         void construct() { }
 170         template <typename ArgT, typename... Args>
 171         void construct(ArgT &&arg, Args&&... args)
 172         {
 173                 *this << std::forward<ArgT>(arg);
 174                 construct(std::forward<Args>(args)...);
 175         }
 176
 177         StringType m_string;
 178         Properties m_properties;
 179 };
 180
 181 typedef BasicBuffer<char> Buffer;
 182 typedef BasicBuffer<wchar_t> WBuffer;
 183
 184 template <typename OutputStreamT, typename CharT>
 185 OutputStreamT &operator<<(OutputStreamT &os, const BasicBuffer<CharT> &buffer)
 186 {
 187         if (buffer.properties().empty())
 188                 os << buffer.str();
 189         else
 190         {
 191                 auto &s = buffer.str();
 192                 auto &ps = buffer.properties();
 193                 auto p = ps.begin();
 194                 for (size_t i = 0;; ++i)
 195                 {
 196                         for (; p != ps.end() && p->first == i; ++p)
 197                                 os << p->second;
 198                         if (i < s.size())
 199                                 os << s[i];
 200                         else
 201                                 break;
 202                 }
 203         }
 204         return os;
 205 }
 206
 207 }
 208
 209 #endif // NCMPCPP_STRBUFFER_H