src/format_impl.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_HAVE_FORMAT_IMPL_H
  22 #define NCMPCPP_HAVE_FORMAT_IMPL_H
  23
  24 #include <boost/variant.hpp>
  25
  26 #include "format.h"
  27 #include "menu.h"
  28 #include "song.h"
  29 #include "strbuffer.h"
  30 #include "utility/functional.h"
  31 #include "utility/wide_string.h"
  32
  33 namespace Format {
  34
  35 // Commutative binary operation such that:
  36 // - Empty + Empty = Empty
  37 // - Empty + Missing = Missing
  38 // - Empty + Ok = Ok
  39 // - Missing + Missing = Missing
  40 // - Missing + Ok = Missing
  41 // - Ok + Ok = Ok
  42 inline Result &operator+=(Result &base, Result result)
  43 {
  44         if (base == Result::Missing || result == Result::Missing)
  45                 base = Result::Missing;
  46         else if (base == Result::Ok || result == Result::Ok)
  47                 base = Result::Ok;
  48         return base;
  49 }
  50
  51 /*inline std::ostream &operator<<(std::ostream &os, Result r)
  52 {
  53         switch (r)
  54         {
  55                 case Result::Empty:
  56                         os << "empty";
  57                         break;
  58                 case Result::Missing:
  59                         os << "missing";
  60                         break;
  61                 case Result::Ok:
  62                         os << "ok";
  63                         break;
  64         }
  65         return os;
  66 }*/
  67
  68 template <typename CharT, typename OutputT, typename SecondOutputT = OutputT>
  69 struct Printer: boost::static_visitor<Result>
  70 {
  71         typedef std::basic_string<CharT> StringT;
  72
  73         Printer(OutputT &os, const MPD::Song *song, SecondOutputT *second_os, const unsigned flags)
  74         : m_output(os)
  75         , m_song(song)
  76         , m_output_switched(false)
  77         , m_second_os(second_os)
  78         , m_no_output(0)
  79         , m_flags(flags)
  80         { }
  81
  82         Result operator()(const StringT &s)
  83         {
  84                 if (!s.empty())
  85                 {
  86                         output(s);
  87                         return Result::Ok;
  88                 }
  89                 else
  90                         return Result::Empty;
  91         }
  92
  93         Result operator()(const NC::Color &c)
  94         {
  95                 if (m_flags & Flags::Color)
  96                         output(c);
  97                 return Result::Empty;
  98         }
  99
 100         Result operator()(NC::Format fmt)
 101         {
 102                 if (m_flags & Flags::Format)
 103                         output(fmt);
 104                 return Result::Empty;
 105         }
 106
 107         Result operator()(OutputSwitch)
 108         {
 109                 if (!m_no_output)
 110                         m_output_switched = true;
 111                 return Result::Ok;
 112         }
 113
 114         Result operator()(const SongTag &st)
 115         {
 116                 StringT tags;
 117                 if (m_flags & Flags::Tag && m_song != nullptr)
 118                 {
 119                         tags = convertString<CharT, char>::apply(
 120                                 m_song->getTags(st.function())
 121                         );
 122                 }
 123                 if (!tags.empty())
 124                 {
 125                         if (st.delimiter() > 0)
 126                         {
 127                                 // shorten date/length by simple truncation
 128                                 if (st.function() == &MPD::Song::getDate || st.function() == &MPD::Song::getLength)
 129                                         tags.resize(st.delimiter());
 130                                 else
 131                                         tags = wideShorten(tags, st.delimiter());
 132                         }
 133                         output(tags);
 134                         return Result::Ok;
 135                 }
 136                 else
 137                         return Result::Missing;
 138         }
 139
 140         // If all Empty -> Empty, if any Ok -> continue with Ok, if any Missing -> stop with Empty.
 141         Result operator()(const Group<CharT> &group)
 142         {
 143                 auto visit = [this, &group] {
 144                         Result result = Result::Empty;
 145                         for (const auto &ex : group.base())
 146                         {
 147                                 result += boost::apply_visitor(*this, ex);
 148                                 if (result == Result::Missing)
 149                                 {
 150                                         result = Result::Empty;
 151                                         break;
 152                                 }
 153                         }
 154                         return result;
 155                 };
 156
 157                 ++m_no_output;
 158                 Result result = visit();
 159                 --m_no_output;
 160                 if (!m_no_output && result == Result::Ok)
 161                         visit();
 162                 return result;
 163         }
 164
 165         // If all Empty or Missing -> Empty, if any Ok -> stop with Ok.
 166         Result operator()(const FirstOf<CharT> &first_of)
 167         {
 168                 for (const auto &ex : first_of.base())
 169                 {
 170                         if (boost::apply_visitor(*this, ex) == Result::Ok)
 171                                 return Result::Ok;
 172                 }
 173                 return Result::Empty;
 174         }
 175
 176 private:
 177         // generic version for streams (buffers, menus)
 178         template <typename ValueT, typename OutputStreamT>
 179         struct output_ {
 180                 static void exec(OutputStreamT &os, const ValueT &value) {
 181                         os << value;
 182                 }
 183         };
 184         // specialization for strings (input/output)
 185         template <typename SomeCharT, typename OtherCharT>
 186         struct output_<std::basic_string<SomeCharT>, std::basic_string<OtherCharT>> {
 187                 typedef std::basic_string<SomeCharT> SomeString;
 188                 typedef std::basic_string<OtherCharT> OtherString;
 189
 190                 // compile only if string types are the same
 191                 static typename std::enable_if<
 192                         std::is_same<SomeString, OtherString>::value,
 193                         void
 194                 >::type exec(SomeString &result, const OtherString &s) {
 195                         result += s;
 196                 }
 197         };
 198         // when writing to a string, we should ignore all other
 199         // properties. if this code is reached, throw an exception.
 200         template <typename ValueT, typename SomeCharT>
 201         struct output_<ValueT, std::basic_string<SomeCharT>> {
 202                 static void exec(std::basic_string<CharT> &, const ValueT &) {
 203                         throw std::logic_error("non-string property can't be appended to the string");
 204                 }
 205         };
 206
 207         template <typename ValueT>
 208         void output(const ValueT &value) const
 209         {
 210                 if (!m_no_output)
 211                 {
 212                         if (m_output_switched && m_second_os != nullptr)
 213                                 output_<ValueT, SecondOutputT>::exec(*m_second_os, value);
 214                         else
 215                                 output_<ValueT, OutputT>::exec(m_output, value);
 216                 }
 217         }
 218
 219         OutputT &m_output;
 220         const MPD::Song *m_song;
 221
 222         bool m_output_switched;
 223         SecondOutputT *m_second_os;
 224
 225         unsigned m_no_output;
 226         const unsigned m_flags;
 227 };
 228
 229 template <typename CharT, typename VisitorT>
 230 void visit(VisitorT &visitor, const AST<CharT> &ast)
 231 {
 232         for (const auto &ex : ast.base())
 233                 boost::apply_visitor(visitor, ex);
 234 }
 235
 236 template <typename CharT, typename ItemT>
 237 void print(const AST<CharT> &ast, NC::Menu<ItemT> &menu, const MPD::Song *song,
 238            NC::BasicBuffer<CharT> *buffer, const unsigned flags)
 239 {
 240         Printer<CharT, NC::Menu<ItemT>, NC::Buffer> printer(menu, song, buffer, flags);
 241         visit(printer, ast);
 242 }
 243
 244 template <typename CharT>
 245 void print(const AST<CharT> &ast, NC::BasicBuffer<CharT> &buffer,
 246            const MPD::Song *song, const unsigned flags)
 247 {
 248         Printer<CharT, NC::BasicBuffer<CharT>> printer(buffer, song, &buffer, flags);
 249         visit(printer, ast);
 250 }
 251
 252 template <typename CharT>
 253 std::basic_string<CharT> stringify(const AST<CharT> &ast, const MPD::Song *song)
 254 {
 255         std::basic_string<CharT> result;
 256         Printer<CharT, std::basic_string<CharT>> printer(result, song, &result, Flags::Tag);
 257         visit(printer, ast);
 258         return result;
 259 }
 260
 261 }
 262
 263 #endif // NCMPCPP_HAVE_FORMAT__IMPL_H