src/strbuffer.h

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2014 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         void clear()
  94         {
  95                 m_string.clear();
  96                 m_properties.clear();
  97         }
  98
  99         BasicBuffer<CharT> &operator<<(int n)
 100         {
 101                 m_string += boost::lexical_cast<StringType>(n);
 102                 return *this;
 103         }
 104
 105         BasicBuffer<CharT> &operator<<(long int n)
 106         {
 107                 m_string += boost::lexical_cast<StringType>(n);
 108                 return *this;
 109         }
 110
 111         BasicBuffer<CharT> &operator<<(unsigned int n)
 112         {
 113                 m_string += boost::lexical_cast<StringType>(n);
 114                 return *this;
 115         }
 116
 117         BasicBuffer<CharT> &operator<<(unsigned long int n)
 118         {
 119                 m_string += boost::lexical_cast<StringType>(n);
 120                 return *this;
 121         }
 122
 123         BasicBuffer<CharT> &operator<<(CharT c)
 124         {
 125                 m_string += c;
 126                 return *this;
 127         }
 128
 129         BasicBuffer<CharT> &operator<<(const CharT *s)
 130         {
 131                 m_string += s;
 132                 return *this;
 133         }
 134
 135         BasicBuffer<CharT> &operator<<(const StringType &s)
 136         {
 137                 m_string += s;
 138                 return *this;
 139         }
 140
 141         BasicBuffer<CharT> &operator<<(Color color)
 142         {
 143                 addProperty(m_string.size(), color);
 144                 return *this;
 145         }
 146
 147         BasicBuffer<CharT> &operator<<(Format format)
 148         {
 149                 addProperty(m_string.size(), format);
 150                 return *this;
 151         }
 152
 153         // static variadic initializer. used instead of a proper constructor because
 154         // it's too polymorphic and would end up invoked as a copy/move constructor.
 155         template <typename... Args>
 156         static BasicBuffer init(Args&&... args)
 157         {
 158                 BasicBuffer result;
 159                 result.construct(std::forward<Args>(args)...);
 160                 return result;
 161         }
 162
 163 private:
 164         void construct() { }
 165         template <typename ArgT, typename... Args>
 166         void construct(ArgT &&arg, Args&&... args)
 167         {
 168                 *this << std::forward<ArgT>(arg);
 169                 construct(std::forward<Args>(args)...);
 170         }
 171
 172         StringType m_string;
 173         Properties m_properties;
 174 };
 175
 176 typedef BasicBuffer<char> Buffer;
 177 typedef BasicBuffer<wchar_t> WBuffer;
 178
 179 template <typename OutputStreamT, typename CharT>
 180 OutputStreamT &operator<<(OutputStreamT &os, const BasicBuffer<CharT> &buffer)
 181 {
 182         if (buffer.properties().empty())
 183                 os << buffer.str();
 184         else
 185         {
 186                 auto &s = buffer.str();
 187                 auto &ps = buffer.properties();
 188                 auto p = ps.begin();
 189                 for (size_t i = 0;; ++i)
 190                 {
 191                         for (; p != ps.end() && p->first == i; ++p)
 192                                 os << p->second;
 193                         if (i < s.size())
 194                                 os << s[i];
 195                         else
 196                                 break;
 197                 }
 198         }
 199         return os;
 200 }
 201
 202 }
 203
 204 #endif // NCMPCPP_STRBUFFER_H