src/mpdpp.cpp

   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 #include <cassert>
  22 #include <cstdlib>
  23 #include <algorithm>
  24 #include <map>
  25
  26 #include "charset.h"
  27 #include "mpdpp.h"
  28
  29 MPD::Connection Mpd;
  30
  31 namespace {
  32
  33 template <typename ObjectT, typename SourceT>
  34 std::function<bool(typename MPD::Iterator<ObjectT>::State &)>
  35 defaultFetcher(SourceT *(fetcher)(mpd_connection *))
  36 {
  37         return [fetcher](typename MPD::Iterator<ObjectT>::State &state) {
  38                 auto src = fetcher(state.connection());
  39                 if (src != nullptr)
  40                 {
  41                         state.setObject(src);
  42                         return true;
  43                 }
  44                 else
  45                         return false;
  46         };
  47 }
  48
  49 bool fetchItemSong(MPD::SongIterator::State &state)
  50 {
  51         auto src = mpd_recv_entity(state.connection());
  52         while (src != nullptr && mpd_entity_get_type(src) != MPD_ENTITY_TYPE_SONG)
  53         {
  54                 mpd_entity_free(src);
  55                 src = mpd_recv_entity(state.connection());
  56         }
  57         if (src != nullptr)
  58         {
  59                 state.setObject(mpd_song_dup(mpd_entity_get_song(src)));
  60                 mpd_entity_free(src);
  61                 return true;
  62         }
  63         else
  64                 return false;
  65 }
  66
  67 }
  68
  69 namespace MPD {
  70
  71 void checkConnectionErrors(mpd_connection *conn)
  72 {
  73         mpd_error code = mpd_connection_get_error(conn);
  74         if (code != MPD_ERROR_SUCCESS)
  75         {
  76                 std::string msg = mpd_connection_get_error_message(conn);
  77                 if (code == MPD_ERROR_SERVER)
  78                 {
  79                         mpd_server_error server_code = mpd_connection_get_server_error(conn);
  80                         bool clearable = mpd_connection_clear_error(conn);
  81                         throw ServerError(server_code, msg, clearable);
  82                 }
  83                 else
  84                 {
  85                         bool clearable = mpd_connection_clear_error(conn);
  86                         throw ClientError(code, msg, clearable);
  87                 }
  88         }
  89 }
  90
  91 Connection::Connection() : m_connection(nullptr),
  92                                 m_command_list_active(false),
  93                                 m_idle(false),
  94                                 m_host("localhost"),
  95                                 m_port(6600),
  96                                 m_timeout(15)
  97 {
  98 }
  99
 100 void Connection::Connect()
 101 {
 102         assert(!m_connection);
 103         try
 104         {
 105                 m_connection.reset(mpd_connection_new(m_host.c_str(), m_port, m_timeout * 1000));
 106                 checkErrors();
 107                 if (!m_password.empty())
 108                         SendPassword();
 109                 m_fd = mpd_connection_get_fd(m_connection.get());
 110                 checkErrors();
 111         }
 112         catch (MPD::ClientError &e)
 113         {
 114                 Disconnect();
 115                 throw e;
 116         }
 117 }
 118
 119 bool Connection::Connected() const
 120 {
 121         return m_connection.get() != nullptr;
 122 }
 123
 124 void Connection::Disconnect()
 125 {
 126         m_connection = nullptr;
 127         m_command_list_active = false;
 128         m_idle = false;
 129 }
 130
 131 unsigned Connection::Version() const
 132 {
 133         return m_connection ? mpd_connection_get_server_version(m_connection.get())[1] : 0;
 134 }
 135
 136 void Connection::SetHostname(const std::string &host)
 137 {
 138         size_t at = host.find("@");
 139         if (at != std::string::npos)
 140         {
 141                 m_password = host.substr(0, at);
 142                 m_host = host.substr(at+1);
 143         }
 144         else
 145                 m_host = host;
 146 }
 147
 148 void Connection::SendPassword()
 149 {
 150         assert(m_connection);
 151         noidle();
 152         assert(!m_command_list_active);
 153         mpd_run_password(m_connection.get(), m_password.c_str());
 154         checkErrors();
 155 }
 156
 157 void Connection::idle()
 158 {
 159         checkConnection();
 160         if (!m_idle)
 161         {
 162                 mpd_send_idle(m_connection.get());
 163                 checkErrors();
 164         }
 165         m_idle = true;
 166 }
 167
 168 int Connection::noidle()
 169 {
 170         checkConnection();
 171         int flags = 0;
 172         if (m_idle && mpd_send_noidle(m_connection.get()))
 173         {
 174                 m_idle = false;
 175                 flags = mpd_recv_idle(m_connection.get(), true);
 176                 mpd_response_finish(m_connection.get());
 177                 checkErrors();
 178         }
 179         return flags;
 180 }
 181
 182 Statistics Connection::getStatistics()
 183 {
 184         prechecks();
 185         mpd_stats *stats = mpd_run_stats(m_connection.get());
 186         checkErrors();
 187         return Statistics(stats);
 188 }
 189
 190 Status Connection::getStatus()
 191 {
 192         prechecks();
 193         mpd_status *status = mpd_run_status(m_connection.get());
 194         checkErrors();
 195         return Status(status);
 196 }
 197
 198 void Connection::UpdateDirectory(const std::string &path)
 199 {
 200         prechecksNoCommandsList();
 201         mpd_run_update(m_connection.get(), path.c_str());
 202         checkErrors();
 203 }
 204
 205 void Connection::Play()
 206 {
 207         prechecksNoCommandsList();
 208         mpd_run_play(m_connection.get());
 209         checkErrors();
 210 }
 211
 212 void Connection::Play(int pos)
 213 {
 214         prechecksNoCommandsList();
 215         mpd_run_play_pos(m_connection.get(), pos);
 216         checkErrors();
 217 }
 218
 219 void Connection::PlayID(int id)
 220 {
 221         prechecksNoCommandsList();
 222         mpd_run_play_id(m_connection.get(), id);
 223         checkErrors();
 224 }
 225
 226 void Connection::Pause(bool state)
 227 {
 228         prechecksNoCommandsList();
 229         mpd_run_pause(m_connection.get(), state);
 230         checkErrors();
 231 }
 232
 233 void Connection::Toggle()
 234 {
 235         prechecksNoCommandsList();
 236         mpd_run_toggle_pause(m_connection.get());
 237         checkErrors();
 238 }
 239
 240 void Connection::Stop()
 241 {
 242         prechecksNoCommandsList();
 243         mpd_run_stop(m_connection.get());
 244         checkErrors();
 245 }
 246
 247 void Connection::Next()
 248 {
 249         prechecksNoCommandsList();
 250         mpd_run_next(m_connection.get());
 251         checkErrors();
 252 }
 253
 254 void Connection::Prev()
 255 {
 256         prechecksNoCommandsList();
 257         mpd_run_previous(m_connection.get());
 258         checkErrors();
 259 }
 260
 261 void Connection::Move(unsigned from, unsigned to)
 262 {
 263         prechecks();
 264         if (m_command_list_active)
 265                 mpd_send_move(m_connection.get(), from, to);
 266         else
 267         {
 268                 mpd_run_move(m_connection.get(), from, to);
 269                 checkErrors();
 270         }
 271 }
 272
 273 void Connection::Swap(unsigned from, unsigned to)
 274 {
 275         prechecks();
 276         if (m_command_list_active)
 277                 mpd_send_swap(m_connection.get(), from, to);
 278         else
 279         {
 280                 mpd_run_swap(m_connection.get(), from, to);
 281                 checkErrors();
 282         }
 283 }
 284
 285 void Connection::Seek(unsigned pos, unsigned where)
 286 {
 287         prechecksNoCommandsList();
 288         mpd_run_seek_pos(m_connection.get(), pos, where);
 289         checkErrors();
 290 }
 291
 292 void Connection::Shuffle()
 293 {
 294         prechecksNoCommandsList();
 295         mpd_run_shuffle(m_connection.get());
 296         checkErrors();
 297 }
 298
 299 void Connection::ShuffleRange(unsigned start, unsigned end)
 300 {
 301         prechecksNoCommandsList();
 302         mpd_run_shuffle_range(m_connection.get(), start, end);
 303         checkErrors();
 304 }
 305
 306 void Connection::ClearMainPlaylist()
 307 {
 308         prechecksNoCommandsList();
 309         mpd_run_clear(m_connection.get());
 310         checkErrors();
 311 }
 312
 313 void Connection::ClearPlaylist(const std::string &playlist)
 314 {
 315         prechecksNoCommandsList();
 316         mpd_run_playlist_clear(m_connection.get(), playlist.c_str());
 317         checkErrors();
 318 }
 319
 320 void Connection::AddToPlaylist(const std::string &path, const Song &s)
 321 {
 322         AddToPlaylist(path, s.getURI());
 323 }
 324
 325 void Connection::AddToPlaylist(const std::string &path, const std::string &file)
 326 {
 327         prechecks();
 328         if (m_command_list_active)
 329                 mpd_send_playlist_add(m_connection.get(), path.c_str(), file.c_str());
 330         else
 331         {
 332                 mpd_run_playlist_add(m_connection.get(), path.c_str(), file.c_str());
 333                 checkErrors();
 334         }
 335 }
 336
 337 void Connection::PlaylistMove(const std::string &path, int from, int to)
 338 {
 339         prechecks();
 340         if (m_command_list_active)
 341                 mpd_send_playlist_move(m_connection.get(), path.c_str(), from, to);
 342         else
 343         {
 344                 mpd_send_playlist_move(m_connection.get(), path.c_str(), from, to);
 345                 mpd_response_finish(m_connection.get());
 346                 checkErrors();
 347         }
 348 }
 349
 350 void Connection::Rename(const std::string &from, const std::string &to)
 351 {
 352         prechecksNoCommandsList();
 353         mpd_run_rename(m_connection.get(), from.c_str(), to.c_str());
 354         checkErrors();
 355 }
 356
 357 SongIterator Connection::GetPlaylistChanges(unsigned version)
 358 {
 359         prechecksNoCommandsList();
 360         mpd_send_queue_changes_meta(m_connection.get(), version);
 361         checkErrors();
 362         return SongIterator(m_connection.get(), defaultFetcher<Song>(mpd_recv_song));
 363 }
 364
 365 Song Connection::GetCurrentSong()
 366 {
 367         prechecksNoCommandsList();
 368         mpd_send_current_song(m_connection.get());
 369         mpd_song *s = mpd_recv_song(m_connection.get());
 370         mpd_response_finish(m_connection.get());
 371         checkErrors();
 372         return Song(s);
 373 }
 374
 375 Song Connection::GetSong(const std::string &path)
 376 {
 377         prechecksNoCommandsList();
 378         mpd_send_list_all_meta(m_connection.get(), path.c_str());
 379         mpd_song *s = mpd_recv_song(m_connection.get());
 380         mpd_response_finish(m_connection.get());
 381         checkErrors();
 382         return Song(s);
 383 }
 384
 385 SongIterator Connection::GetPlaylistContent(const std::string &path)
 386 {
 387         prechecksNoCommandsList();
 388         mpd_send_list_playlist_meta(m_connection.get(), path.c_str());
 389         SongIterator result(m_connection.get(), defaultFetcher<Song>(mpd_recv_song));
 390         checkErrors();
 391         return result;
 392 }
 393
 394 SongIterator Connection::GetPlaylistContentNoInfo(const std::string &path)
 395 {
 396         prechecksNoCommandsList();
 397         mpd_send_list_playlist(m_connection.get(), path.c_str());
 398         SongIterator result(m_connection.get(), defaultFetcher<Song>(mpd_recv_song));
 399         checkErrors();
 400         return result;
 401 }
 402
 403 StringIterator Connection::GetSupportedExtensions()
 404 {
 405         prechecksNoCommandsList();
 406         mpd_send_command(m_connection.get(), "decoders", NULL);
 407         checkErrors();
 408         return StringIterator(m_connection.get(), [](StringIterator::State &state) {
 409                 auto src = mpd_recv_pair_named(state.connection(), "suffix");
 410                 if (src != nullptr)
 411                 {
 412                         state.setObject(src->value);
 413                         mpd_return_pair(state.connection(), src);
 414                         return true;
 415                 }
 416                 else
 417                         return false;
 418         });
 419 }
 420
 421 void Connection::SetRepeat(bool mode)
 422 {
 423         prechecksNoCommandsList();
 424         mpd_run_repeat(m_connection.get(), mode);
 425         checkErrors();
 426 }
 427
 428 void Connection::SetRandom(bool mode)
 429 {
 430         prechecksNoCommandsList();
 431         mpd_run_random(m_connection.get(), mode);
 432         checkErrors();
 433 }
 434
 435 void Connection::SetSingle(bool mode)
 436 {
 437         prechecksNoCommandsList();
 438         mpd_run_single(m_connection.get(), mode);
 439         checkErrors();
 440 }
 441
 442 void Connection::SetConsume(bool mode)
 443 {
 444         prechecksNoCommandsList();
 445         mpd_run_consume(m_connection.get(), mode);
 446         checkErrors();
 447 }
 448
 449 void Connection::SetVolume(unsigned vol)
 450 {
 451         prechecksNoCommandsList();
 452         mpd_run_set_volume(m_connection.get(), vol);
 453         checkErrors();
 454 }
 455
 456 std::string Connection::GetReplayGainMode()
 457 {
 458         prechecksNoCommandsList();
 459         mpd_send_command(m_connection.get(), "replay_gain_status", NULL);
 460         std::string result;
 461         if (mpd_pair *pair = mpd_recv_pair_named(m_connection.get(), "replay_gain_mode"))
 462         {
 463                 result = pair->value;
 464                 mpd_return_pair(m_connection.get(), pair);
 465         }
 466         mpd_response_finish(m_connection.get());
 467         checkErrors();
 468         return result;
 469 }
 470
 471 void Connection::SetReplayGainMode(ReplayGainMode mode)
 472 {
 473         prechecksNoCommandsList();
 474         const char *rg_mode;
 475         switch (mode)
 476         {
 477                 case rgmOff:
 478                         rg_mode = "off";
 479                         break;
 480                 case rgmTrack:
 481                         rg_mode = "track";
 482                         break;
 483                 case rgmAlbum:
 484                         rg_mode = "album";
 485                         break;
 486                 default:
 487                         rg_mode = "";
 488                         break;
 489         }
 490         mpd_send_command(m_connection.get(), "replay_gain_mode", rg_mode, NULL);
 491         mpd_response_finish(m_connection.get());
 492         checkErrors();
 493 }
 494
 495 void Connection::SetCrossfade(unsigned crossfade)
 496 {
 497         prechecksNoCommandsList();
 498         mpd_run_crossfade(m_connection.get(), crossfade);
 499         checkErrors();
 500 }
 501
 502 void Connection::SetPriority(const Song &s, int prio)
 503 {
 504         prechecks();
 505         if (m_command_list_active)
 506                 mpd_send_prio_id(m_connection.get(), prio, s.getID());
 507         else
 508         {
 509                 mpd_run_prio_id(m_connection.get(), prio, s.getID());
 510                 checkErrors();
 511         }
 512 }
 513
 514 int Connection::AddSong(const std::string &path, int pos)
 515 {
 516         prechecks();
 517         int id;
 518         if (pos < 0)
 519                 mpd_send_add_id(m_connection.get(), path.c_str());
 520         else
 521                 mpd_send_add_id_to(m_connection.get(), path.c_str(), pos);
 522         if (!m_command_list_active)
 523         {
 524                 id = mpd_recv_song_id(m_connection.get());
 525                 mpd_response_finish(m_connection.get());
 526                 checkErrors();
 527         }
 528         else
 529                 id = 0;
 530         return id;
 531 }
 532
 533 int Connection::AddSong(const Song &s, int pos)
 534 {
 535         return AddSong((!s.isFromDatabase() ? "file://" : "") + s.getURI(), pos);
 536 }
 537
 538 void Connection::Add(const std::string &path)
 539 {
 540         prechecks();
 541         if (m_command_list_active)
 542                 mpd_send_add(m_connection.get(), path.c_str());
 543         else
 544         {
 545                 mpd_run_add(m_connection.get(), path.c_str());
 546                 checkErrors();
 547         }
 548 }
 549
 550 bool Connection::AddRandomTag(mpd_tag_type tag, size_t number)
 551 {
 552         std::vector<std::string> tags(
 553                 std::make_move_iterator(GetList(tag)),
 554                 std::make_move_iterator(StringIterator())
 555         );
 556         if (number > tags.size())
 557                 return false;
 558
 559         std::random_shuffle(tags.begin(), tags.end());
 560         auto it = tags.begin();
 561         for (size_t i = 0; i < number && it != tags.end(); ++i)
 562         {
 563                 StartSearch(true);
 564                 AddSearch(tag, *it++);
 565                 std::vector<std::string> paths;
 566                 MPD::SongIterator s = CommitSearchSongs(), end;
 567                 for (; s != end; ++s)
 568                         paths.push_back(s->getURI());
 569                 StartCommandsList();
 570                 for (const auto &path : paths)
 571                         AddSong(path);
 572                 CommitCommandsList();
 573         }
 574         return true;
 575 }
 576
 577 bool Connection::AddRandomSongs(size_t number)
 578 {
 579         prechecksNoCommandsList();
 580         std::vector<std::string> files;
 581         mpd_send_list_all(m_connection.get(), "/");
 582         while (mpd_pair *item = mpd_recv_pair_named(m_connection.get(), "file"))
 583         {
 584                 files.push_back(item->value);
 585                 mpd_return_pair(m_connection.get(), item);
 586         }
 587         mpd_response_finish(m_connection.get());
 588         checkErrors();
 589
 590         if (number > files.size())
 591         {
 592                 //if (itsErrorHandler)
 593                 //      itsErrorHandler(this, 0, "Requested number of random songs is bigger than size of your library", itsErrorHandlerUserdata);
 594                 return false;
 595         }
 596         else
 597         {
 598                 std::random_shuffle(files.begin(), files.end());
 599                 StartCommandsList();
 600                 auto it = files.begin();
 601                 for (size_t i = 0; i < number && it != files.end(); ++i, ++it)
 602                         AddSong(*it);
 603                 CommitCommandsList();
 604         }
 605         return true;
 606 }
 607
 608 void Connection::Delete(unsigned pos)
 609 {
 610         prechecks();
 611         mpd_send_delete(m_connection.get(), pos);
 612         if (!m_command_list_active)
 613         {
 614                 mpd_response_finish(m_connection.get());
 615                 checkErrors();
 616         }
 617 }
 618
 619 void Connection::PlaylistDelete(const std::string &playlist, unsigned pos)
 620 {
 621         prechecks();
 622         mpd_send_playlist_delete(m_connection.get(), playlist.c_str(), pos);
 623         if (!m_command_list_active)
 624         {
 625                 mpd_response_finish(m_connection.get());
 626                 checkErrors();
 627         }
 628 }
 629
 630 void Connection::StartCommandsList()
 631 {
 632         prechecksNoCommandsList();
 633         mpd_command_list_begin(m_connection.get(), true);
 634         m_command_list_active = true;
 635         checkErrors();
 636 }
 637
 638 void Connection::CommitCommandsList()
 639 {
 640         prechecks();
 641         assert(m_command_list_active);
 642         mpd_command_list_end(m_connection.get());
 643         mpd_response_finish(m_connection.get());
 644         m_command_list_active = false;
 645         checkErrors();
 646 }
 647
 648 void Connection::DeletePlaylist(const std::string &name)
 649 {
 650         prechecksNoCommandsList();
 651         mpd_run_rm(m_connection.get(), name.c_str());
 652         checkErrors();
 653 }
 654
 655 void Connection::LoadPlaylist(const std::string &name)
 656 {
 657         prechecksNoCommandsList();
 658         mpd_run_load(m_connection.get(), name.c_str());
 659         checkErrors();
 660 }
 661
 662 void Connection::SavePlaylist(const std::string &name)
 663 {
 664         prechecksNoCommandsList();
 665         mpd_send_save(m_connection.get(), name.c_str());
 666         mpd_response_finish(m_connection.get());
 667         checkErrors();
 668 }
 669
 670 PlaylistIterator Connection::GetPlaylists()
 671 {
 672         prechecksNoCommandsList();
 673         mpd_send_list_playlists(m_connection.get());
 674         checkErrors();
 675         return PlaylistIterator(m_connection.get(), defaultFetcher<Playlist>(mpd_recv_playlist));
 676 }
 677
 678 StringIterator Connection::GetList(mpd_tag_type type)
 679 {
 680         prechecksNoCommandsList();
 681         mpd_search_db_tags(m_connection.get(), type);
 682         mpd_search_commit(m_connection.get());
 683         checkErrors();
 684         return StringIterator(m_connection.get(), [type](StringIterator::State &state) {
 685                 auto src = mpd_recv_pair_tag(state.connection(), type);
 686                 if (src != nullptr)
 687                 {
 688                         state.setObject(src->value);
 689                         mpd_return_pair(state.connection(), src);
 690                         return true;
 691                 }
 692                 else
 693                         return false;
 694         });
 695 }
 696
 697 void Connection::StartSearch(bool exact_match)
 698 {
 699         prechecksNoCommandsList();
 700         mpd_search_db_songs(m_connection.get(), exact_match);
 701 }
 702
 703 void Connection::StartFieldSearch(mpd_tag_type item)
 704 {
 705         prechecksNoCommandsList();
 706         mpd_search_db_tags(m_connection.get(), item);
 707 }
 708
 709 void Connection::AddSearch(mpd_tag_type item, const std::string &str) const
 710 {
 711         checkConnection();
 712         mpd_search_add_tag_constraint(m_connection.get(), MPD_OPERATOR_DEFAULT, item, str.c_str());
 713 }
 714
 715 void Connection::AddSearchAny(const std::string &str) const
 716 {
 717         checkConnection();
 718         mpd_search_add_any_tag_constraint(m_connection.get(), MPD_OPERATOR_DEFAULT, str.c_str());
 719 }
 720
 721 void Connection::AddSearchURI(const std::string &str) const
 722 {
 723         checkConnection();
 724         mpd_search_add_uri_constraint(m_connection.get(), MPD_OPERATOR_DEFAULT, str.c_str());
 725 }
 726
 727 SongIterator Connection::CommitSearchSongs()
 728 {
 729         prechecksNoCommandsList();
 730         mpd_search_commit(m_connection.get());
 731         checkErrors();
 732         return SongIterator(m_connection.get(), defaultFetcher<Song>(mpd_recv_song));
 733 }
 734
 735 ItemIterator Connection::GetDirectory(const std::string &directory)
 736 {
 737         prechecksNoCommandsList();
 738         mpd_send_list_meta(m_connection.get(), directory.c_str());
 739         checkErrors();
 740         return ItemIterator(m_connection.get(), defaultFetcher<Item>(mpd_recv_entity));
 741 }
 742
 743 SongIterator Connection::GetDirectoryRecursive(const std::string &directory)
 744 {
 745         prechecksNoCommandsList();
 746         mpd_send_list_all_meta(m_connection.get(), directory.c_str());
 747         checkErrors();
 748         return SongIterator(m_connection.get(), fetchItemSong);
 749 }
 750
 751 DirectoryIterator Connection::GetDirectories(const std::string &directory)
 752 {
 753         prechecksNoCommandsList();
 754         mpd_send_list_meta(m_connection.get(), directory.c_str());
 755         checkErrors();
 756         return DirectoryIterator(m_connection.get(), defaultFetcher<Directory>(mpd_recv_directory));
 757 }
 758
 759 SongIterator Connection::GetSongs(const std::string &directory)
 760 {
 761         prechecksNoCommandsList();
 762         mpd_send_list_meta(m_connection.get(), directory.c_str());
 763         checkErrors();
 764         return SongIterator(m_connection.get(), defaultFetcher<Song>(mpd_recv_song));
 765 }
 766
 767 OutputIterator Connection::GetOutputs()
 768 {
 769         prechecksNoCommandsList();
 770         mpd_send_outputs(m_connection.get());
 771         checkErrors();
 772         return OutputIterator(m_connection.get(), defaultFetcher<Output>(mpd_recv_output));
 773 }
 774
 775 void Connection::EnableOutput(int id)
 776 {
 777         prechecksNoCommandsList();
 778         mpd_run_enable_output(m_connection.get(), id);
 779         checkErrors();
 780 }
 781
 782 void Connection::DisableOutput(int id)
 783 {
 784         prechecksNoCommandsList();
 785         mpd_run_disable_output(m_connection.get(), id);
 786         checkErrors();
 787 }
 788
 789 StringIterator Connection::GetURLHandlers()
 790 {
 791         prechecksNoCommandsList();
 792         mpd_send_list_url_schemes(m_connection.get());
 793         checkErrors();
 794         return StringIterator(m_connection.get(), [](StringIterator::State &state) {
 795                 auto src = mpd_recv_pair_named(state.connection(), "handler");
 796                 if (src != nullptr)
 797                 {
 798                         state.setObject(src->value);
 799                         mpd_return_pair(state.connection(), src);
 800                         return true;
 801                 }
 802                 else
 803                         return false;
 804         });
 805 }
 806
 807 StringIterator Connection::GetTagTypes()
 808 {
 809
 810         prechecksNoCommandsList();
 811         mpd_send_list_tag_types(m_connection.get());
 812         checkErrors();
 813         return StringIterator(m_connection.get(), [](StringIterator::State &state) {
 814                 auto src = mpd_recv_pair_named(state.connection(), "tagtype");
 815                 if (src != nullptr)
 816                 {
 817                         state.setObject(src->value);
 818                         mpd_return_pair(state.connection(), src);
 819                         return true;
 820                 }
 821                 else
 822                         return false;
 823         });
 824 }
 825
 826 void Connection::checkConnection() const
 827 {
 828         if (!m_connection)
 829                 throw ClientError(MPD_ERROR_STATE, "No active MPD connection", false);
 830 }
 831
 832 void Connection::prechecks()
 833 {
 834         checkConnection();
 835         noidle();
 836 }
 837
 838 void Connection::prechecksNoCommandsList()
 839 {
 840         assert(!m_command_list_active);
 841         prechecks();
 842 }
 843
 844 void Connection::checkErrors() const
 845 {
 846         checkConnectionErrors(m_connection.get());
 847 }
 848
 849 }