ocarina/lib/tags.cpp

/*
 * Copyright 2014 (c) Anna Schumaker.
 */

#include <tags.h>
#include <filter.h>

#include <sstream>


Database<Artist>  artist_db("artist.db", true);
Database<Album>   album_db("album.db", true);
Database<Genre>   genre_db("genre.db", true);
Database<Library> library_db("library.db", true);
Database<Track>   track_db("track.db", false);


/**
 *
 * Artist tag
 *
 */

Artist :: Artist() {}

Artist :: Artist(const std::string &s)
	: name(s), lower(filter :: lowercase(name))
{
}

const std::string Artist :: primary_key()
{
	return name;
}

void Artist :: read(File &f)
{
	name  = f.getline();
	lower = filter :: lowercase(name);
}

void Artist :: write(File &f)
{
	f << name;
}



/**
 *
 * Album tag
 *
 */

Album :: Album() {}

Album :: Album(const std::string &s, unsigned int y)
       : name(s), lower(filter :: lowercase(name)), year(y)
{
}

const std::string Album :: primary_key()
{
	std::stringstream ss;
	ss << year << "." << name;
	return ss.str();
}

void Album :: read(File &f)
{
	f >> year;
	name  = f.getline();
	lower = filter :: lowercase(name);
}

void Album :: write(File &f)
{
	f << year << " " << name;
}



/**
 *
 * Genre tag
 *
 */

Genre :: Genre() {}

Genre :: Genre(const std::string &s)
       : name(s), lower(filter :: lowercase(name))
{
}

const std::string Genre :: primary_key()
{
	return name;
}

void Genre :: read(File &f)
{
	name  = f.getline();
	lower = filter :: lowercase(name);
}

void Genre :: write(File &f)
{
	f << name;
}



/**
 *
 * Library tag
 *
 */

Library :: Library()
	 : count(0), enabled(false)
{
}

Library :: Library(const std::string &s)
	 : root_path(s), count(0), enabled(true)
{
}

const std::string Library :: primary_key()
{
	return root_path;
}

void Library :: read(File &f)
{
	f >> enabled;
	root_path = f.getline();
}

void Library :: write(File &f)
{
	f << enabled << " " << root_path;
}



/**
 *
 * Track tag
 *
 */

Track :: Track() {}

Track :: Track(const std::string &f, Library *l)
      : library(l), play_count(0), last_year(0), last_month(0), last_day(0),
         filepath(f.substr(l->root_path.size() + 1))
{
}

const std::string Track :: primary_key()
{
	return path();
}

void Track :: read(File &f)
{
}

void Track :: write(File &f)
{
}

void Track :: tag()
{
}

const std::string Track :: path()
{
	return library->root_path + "/" + filepath;
}

bool Track :: less_than(Track *rhs, sort_t field)
{
	return false;
}



/**
 *
 * Tagdb functions
 *
 */

Track *tagdb :: add_track(const std::string &filepath, Library *library)
{
	unsigned int size = track_db.size();
	Track *track = track_db.insert(Track(filepath, library));
	if (size == track_db.size())
		return NULL;
	return track;
}

Library *tagdb :: add_library(const std::string &filepath)
{
	unsigned int size = library_db.size();
	Library *library = library_db.insert(Library(filepath));
	if (size == library_db.size())
		return NULL;
	return library;
}

void tagdb :: remove_track(unsigned int track_id)
{
	track_db.remove(track_id);
}

void tagdb :: remove_library(unsigned int library_id)
{
	Database<Track>::iterator it;
	for (it = track_db.begin(); it != track_db.end(); it++) {
		if ((*it)->library->id == library_id)
			track_db.remove((*it)->id);
	}
	library_db.remove(library_id);
}

Track *tagdb :: lookup(unsigned int track_id)
{
	return track_db.at(track_id);
}

Database<Track> &tagdb :: get_track_db()
{
	return track_db;
}

Database<Library> &tagdb :: get_library_db()
{
	return library_db;
}