Question

Introduction

Welcome to Rad.io, you've been hired to work on our music streaming app, think of it as Spotify only more rad! You're in charge of handling our customer’s song list. When a user selects a playlist it will load into the list a number of songs. Users can skip to the next song, move to the previous, they can select a song to play next or select a song to add to the end of their list.

Objective

You are given two header files, Song.hpp and RadList.hpp. Song holds a song’s name, artist, album, duration (in seconds) and whether or not it contains explicit lyrics. RadList keeps track of all Song objects in the linked list List. RadList also has an iterator that points to the Song object currently playing.

Complete the implementation of these classes, and make sure all tests pass. Your instructor may require you to keep your header and implementation code seperate in both .hpp and .cpp files. Your code is tested in the provided main.cpp.

You will need to implement the following functions:

• Song Constructor - This should initialize all Song member variables.

• Song Getters - name, artist, album, minutes, seconds and explicit lyrics should all be returned with these member functions. Keep in mind the duration in seconds is stored. The minutes() and seconds() getters should return the minutes and leftover seconds of a song. For example a song with a duration of 291 seconds should return 4 minutes and 51 seconds.

• next() - This should move the nowPlaying iterator to the next song in the list.

• prev() - This should move the nowPlaying iterator to the previous song in the list.

• nowPlaying() - This should return the current Song the nowPlaying iterator is currently pointing to.

• addToList() - This should add the passed in song to the end of the list.

• playNext() - This should add the passed in song as the next song in the list right after the current song playing.

Initially the given code will not compile. As you complete the code, the tests should start to pass in main.cpp.

Source Code Files

You are given “skeleton” code files with declarations that may be incomplete and without any implementation. Implement the code and ensure that all the tests in main.cpp pass successfully.

• Song.hpp: This is to be completed

• RadList.hpp: This is to be completed

• main.cpp: The main function tests the output of your functions. You may wish to add additional tests. During grading your main.cpp file will be replaced with the one you were provided with.

• README.md: You must edit this file to include your name and CSUF email. This information will be used so that we can enter your grades into Titanium.

Hints

The goal of this assignment is to make a class that wraps around a linked list class. You do not need to implement the linked list class, just use the standard library implementation. You can refer to http://www.cplusplus.com/reference/list/list/?kw=list for a list of methods of the std::list class.

The use of iterators is key. It may help to draw out the list with each song and trace through the list with every operation, keeping track of where the nowPlaying iterator should point.

Make sure your code compiles, and then try and solve the logic. Focus on solving one test at a time. It’s recommended that you start with Song.hpp first and then RadList.hpp next. The order of each function is the order in which it’s recommended that you solve.

You do not need to worry about error checking although it would be a good idea!

Codes To Be Completed:

1. Song.hpp

1	#pragma once
2
3	#include <string>
4
5	class Song {
6	private:
7	std::string name_;
8	std::string artist_;
9	std::string album_;
10	unsigned int duration_;
11	bool explicit_lyrics_;
12
13	public:
14	Song(std::string, std::string, std::string, unsigned int, bool);
15
16	std::string name();
17	std::string artist();
18	std::string album();
19	unsigned int minutes();
20	unsigned int seconds();
21	bool explicit_lyrics();
22	};

2. RadList.hpp

1	#pragma once
2	#include <fstream>
3	#include <iostream>
4	#include <list>
5	#include <stdexcept>
6	#include <string>
7
8	#include "Song.hpp"
9
10	class RadList {
11	private:
12	std::list<Song> queue_;
13	std::list<Song>::iterator nowPlaying_;
14	public:
15	void loadPlaylist(const std::string&);
16	void next();
17	void prev();
18	Song nowPlaying();
19	void addToQueue(const Song&);
20	void playNext(const Song&);
21	};
22
23	void RadList::loadPlaylist(const std::string& filename) {
24	std::ifstream playlist(filename);
25
26	if (playlist.is_open()) {
27	std::string name, artist, album, duration, explicit_lyrics, toss;
28
29	// Read in everything from comma seperated values file
30	while (std::getline(playlist, name, ',')) {
31	std::getline(playlist, toss, ' '); // ignore leading space
32	std::getline(playlist, artist, ',');
33	std::getline(playlist, toss, ' '); // ignore leading space
34	std::getline(playlist, album, ',');
35	std::getline(playlist, toss, ' '); // ignore leading space
36	std::getline(playlist, duration, ',');
37	std::getline(playlist, toss, ' '); // ignore leading space
38	std::getline(playlist, explicit_lyrics);
39
40	// Construct Song and add to queue
41	queue_.push_back(Song(name, artist, album, stoi(duration), explicit_lyrics == "true"));
42	}
43
44	playlist.close();
45	nowPlaying_ = queue_.begin();
46	} else {
47	throw std::invalid_argument("Could not open " + filename);
48	}
49	}

3. main.cpp (optional)

#include <iostream>
	#include <string>
	#include "Song.hpp"
	#include "RadList.hpp"
	using std::string;
	using std::cout;
	using std::endl;
	// Helper Functions
	template <typename T>
	void assertEquals(string, T, T);
	int main(int argc, char const *argv[]) {
	RadList jukebox;
	jukebox.loadPlaylist("Downtempo.csv");
	assertEquals("RadList.name()", static_cast<string>("All In Forms"), jukebox.nowPlaying().name());
	jukebox.next();
	assertEquals("RadList.artist()", static_cast<string>("Bonobo"), jukebox.nowPlaying().artist());
	jukebox.prev();
	assertEquals("RadList.minutes()", static_cast<unsigned int>(4), jukebox.nowPlaying().minutes());
	assertEquals("RadList.seconds()", static_cast<unsigned int>(51), jukebox.nowPlaying().seconds());
	jukebox.next();
	jukebox.addToQueue(Song("Black Canyon", "Ana Caravelle", "Basic Climb", 457, false));
	jukebox.next();
	jukebox.playNext(Song("Tumbleweed", "9 Lazy 9", "Sweet Jones", 192, false));
	assertEquals("RadList.name()/album()", jukebox.nowPlaying().name(), jukebox.nowPlaying().album());
	jukebox.addToQueue(Song("Building Steam With A Grain Of Salt", "DJ Shadow", "Endtroducing...", 399, true));
	jukebox.next();
	assertEquals("RadList.playNext())", static_cast<string>("9 Lazy 9"), jukebox.nowPlaying().artist());
	jukebox.next();
	assertEquals("RadList.album()", static_cast<string>("Silver Wilkinson"), jukebox.nowPlaying().album());
	jukebox.next();
	assertEquals("RadList.addToQueue()", static_cast<string>("Ana Caravelle"), jukebox.nowPlaying().artist());
	jukebox.next();
	assertEquals("RadList.explicit_lyrics()", true, jukebox.nowPlaying().explicit_lyrics());
	return 0;
	}
	template <typename T>
	void assertEquals(string test_name, T expected, T actual) {
	if (actual == expected) {
	cout << "[PASSED] " << test_name << endl;
	} else {
	cout << "[FAILED] " << test_name
	<< " - Expected: " << expected
	<< ", Actual: " << actual
	<< endl;
	}
	}

Answer 1

Please let me know if you have any doubts or you want me to modify the answer. And if you find this answer useful then don't forget to rate my answer as thumps up. Thank you! :)

//main.cpp

#include <iostream>
#include <string>

#include "Song.hpp"
#include "RadList.hpp"
using std::string;
using std::cout;
using std::endl;

template <typename T>
void assertEquals(string, T, T);

int main() {
   RadList jukebox;
   jukebox.loadPlaylist("/Users/swapnil/CLionProjects/RadList/Downtempo.csv");
   assertEquals("RadList.name()", static_cast<string>("All In Forms"), jukebox.nowPlaying().name());
   jukebox.next();
   assertEquals("RadList.artist()", static_cast<string>("Bonobo"), jukebox.nowPlaying().artist());
   jukebox.prev();
   assertEquals("RadList.minutes()", static_cast<unsigned int>(4), jukebox.nowPlaying().minutes());
   assertEquals("RadList.seconds()", static_cast<unsigned int>(51), jukebox.nowPlaying().seconds());
   jukebox.next();
   jukebox.addToQueue(Song("Black Canyon", "Ana Caravelle", "Basic Climb", 457, false));
   jukebox.next();
   jukebox.playNext(Song("Tumbleweed", "9 Lazy 9", "Sweet Jones", 192, false));
   assertEquals("RadList.name()/album()", jukebox.nowPlaying().name(), jukebox.nowPlaying().album());
   jukebox.addToQueue(Song("Building Steam With A Grain Of Salt", "DJ Shadow", "Endtroducing...", 399, true));
   jukebox.next();
   assertEquals("RadList.playNext())", static_cast<string>("9 Lazy 9"), jukebox.nowPlaying().artist());
   jukebox.next();
   assertEquals("RadList.album()", static_cast<string>("Silver Wilkinson"), jukebox.nowPlaying().album());
   jukebox.next();
   assertEquals("RadList.addToQueue()", static_cast<string>("Ana Caravelle"), jukebox.nowPlaying().artist());
   jukebox.next();
   assertEquals("RadList.explicit_lyrics()", true, jukebox.nowPlaying().explicit_lyrics());

   return 0;
}

template <typename T>
void assertEquals(string test_name, T expected, T actual) {
   if (actual == expected) {
       cout << "[PASSED] " << test_name << endl;
   }
   else {
       cout << "[FAILED] " << test_name
           << " - Expected: " << expected
           << ", Actual: " << actual
           << endl;
   }
}
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//RadList.cpp
#include "RadList.hpp"

void RadList::loadPlaylist(const std::string& filename) {
    std::ifstream playlist(filename);

    if (playlist.is_open()) {
        std::string name, artist, album, duration, explicit_lyrics, toss;

        while (std::getline(playlist, name, ',')) {
            std::getline(playlist, toss, ' ');         
            std::getline(playlist, artist, ',');
            std::getline(playlist, toss, ' ');        
            std::getline(playlist, album, ',');
            std::getline(playlist, toss, ' ');        
            std::getline(playlist, duration, ',');
            std::getline(playlist, toss, ' ');         
            std::getline(playlist, explicit_lyrics);

            queue_.push_back(Song(name, artist, album, stoi(duration), explicit_lyrics == "true"));
        }

        playlist.close();
        nowPlaying_ = queue_.begin();
    }
    else {
        throw std::invalid_argument("Could not open " + filename);
    }
}
void RadList::next() {
    nowPlaying_++;
};
void RadList::prev() {
    nowPlaying_--;
};
Song RadList::nowPlaying() {
    return *nowPlaying_;
};
void RadList::addToQueue(const Song& addSong) {
    Song temp = addSong;
    queue_.push_back(temp);
};
void RadList::playNext(const Song& addSong) {
    Song temp = addSong;
    std::list<Song>::iterator tempIt;
    tempIt = nowPlaying_;
    queue_.insert(++tempIt, addSong);
};

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//RadList.hpp

#ifndef RADLIST_RADLIST_HPP
#define RADLIST_RADLIST_HPP

#pragma once

#include <fstream>
#include <iostream>
#include <list>
#include <stdexcept>
#include <string>

#include "Song.hpp"

class RadList {
private:
    std::list<Song> queue_;
    std::list<Song>::iterator nowPlaying_;
public:
    void loadPlaylist(const std::string&);
    void next();
    void prev();
    Song nowPlaying();
    void addToQueue(const Song&);
    void playNext(const Song&);
};

#endif //RADLIST_RADLIST_HPP

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Song.cpp
#include "Song.hpp"

Song::Song(std::string name, std::string artist, std::string album,
           unsigned int duration, bool explicitLyrics)
        : name_(name),
          artist_(artist),
          album_(album),
          duration_(duration),
          explicit_lyrics_(explicitLyrics)
{
}

std::string Song::name() {
    return name_;
};
std::string Song::artist() {
    return artist_;
};
std::string Song::album() {
    return album_;
};
unsigned int Song::minutes() {
    return duration_ / 60;
};
unsigned int Song::seconds() {
    return duration_ % 60;
};
bool Song::explicit_lyrics() {
    return explicit_lyrics_;
};

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Song.hpp
#ifndef RADLIST_SONG_HPP
#define RADLIST_SONG_HPP

#pragma once

#include <string>

class Song {
private:
    std::string name_;
    std::string artist_;
    std::string album_;
    unsigned int duration_;
    bool explicit_lyrics_;

public:
    Song(std::string, std::string, std::string, unsigned int, bool);

    std::string name();
    std::string artist();
    std::string album();
    unsigned int minutes();
    unsigned int seconds();
    bool explicit_lyrics();
};

#endif //RADLIST_SONG_HPP

RadList [-/CLionProjects/RadListJ-.../main.cpp RadListmain.cpp Project ▼ *÷ *-Δ cMakeLists.txt, main cpp-品RadListapp RadList.hpp. 品Song.cop Song.hpp 8 using std::string RadList-/CLionProjects/RadList using std::cout; using std::endl; template <typenane T int main() { 10 2 CMakelists.txt Downtempo.csv 14void assertEquals(string, T, T) 愿RadList.cpp RadList.hpp 品Song.cpp 16 RadList jukebox jukebox. LoadPlaylist("/Users/swapniL/CLionProjects/RadList/Rowntempo.csv") assertEquals("RadList.name0", static cast<string ("ALl In Forms"), jukebox.nowPlaying).nane)): jukebox.next); assertEquals("RadList.artist()", static castestring("Bonobg"), jukebox. nowPlaying).artistO jukebox.prev); assertEquals("RadList.minutes ()",staticcastcunsigned int(4), jukebox.nowplaying().minutes() assertEquals("RadList.seconds()", static_castcunsigned ints(51), jukebox. nowPlaying).seconds)) jukebox. next); jukebox.addToQueue(Song("Black Canyon","Ana Caravelle", "Basic Climb", 457, false)) jukebox.next); jukebox.playNext (Song( "Tumb Leweed", 9 Lazy 9,"Sweet Jones", 192, false)): assertEquals("RadList.name()/abum()",ukebox. nowPlaying().name), jukebox.nouPlaying).albun)); jukebox.addToQueue(Song( "Building Steam With A Grain of Salt", "DJ Shadow", "Endt roducing.. .",399, true)) jukebox.next): assertEquals("RadList.playNext())", static_castestring>"9 Lazy 9"), jukebox.nowPlaying).artist)) jukebox.next) assertEquals("RadList.aLbum()", static cast<stringo("Silver Wilkinson"), jukebox.nowPlaying).album)) jukebox.next); assertEquals("RadList.addToQueue()", static castestring>("Ana Caravelle"), jukebox.nouPlaying).artist)) Song.hpp lh Extornal Libraries Scratches and Consoles 23 31 35 RadList Rune /users/swapnil/CLionProjects/RadList /㎝ake-bui ud-debug/RadList [PASSED] RadList.name() [PASSED] RadList.artist PASSED] RadList.minutes [PASSED] RadList. seconds() [PASSED] RadList.name)/album( PASSED] RadList.playNext)) [PASSED] RadList.album() PASSED] RadList.addToQueue) [PASSED] RadList.explicittyrics) Process finished with exit code O Event Log Process finished with exit code O 12:1 LF委 UTF-8# Tab": Context: RadList [D]