ocarina/lib/library.cpp

/*
 * Copyright 2013 (c) Anna Schumaker.
 */
#include <library.h>

#include <glib.h>
#include <taglib/fileref.h>

static Database<library :: Artist> artist_db("artist.db", DB_UNIQUE);
static Database<library :: Album> album_db("album.db", DB_UNIQUE);
static Database<library :: Genre> genre_db("genre.db", DB_UNIQUE);
static Database<library :: Library> library_db("library.db", DB_NORMAL);



/*
 * library :: Artist:  Artist tag information
 */

library :: Artist :: Artist()
	 : name("")
{
}

library :: Artist :: Artist(TagLib :: Tag *tag)
	 : name(tag->artist().to8Bit(true))
{
}

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

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

#ifdef CONFIG_DEBUG
void library :: Artist :: print()
{
	:: print("Artist: %s", name.c_str());
}
#endif /* CONFIG_DEBUG */

bool library :: Artist :: operator==(const library :: Artist &rhs)
{
	return name == rhs.name;
}


/*
 * library :: Album:  Album tag information
 */

library :: Album :: Album()
	 : name(""), year(0), artist_id(0)
{
}

library :: Album :: Album(TagLib :: Tag *tag, unsigned int artist)
	 : name(tag->album().to8Bit(true)), year(tag->year()), artist_id(artist)
{
}

void library :: Album :: read(File &f)
{
	f >> artist_id >> year;
	name = f.getline();
}

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

#ifdef CONFIG_DEBUG
void library :: Album :: print()
{
	:: print("Album: %s (%u) by %s", name.c_str(), year, artist_db[artist_id].name.c_str());
}
#endif /* CONFIG_DEBUG */

bool library :: Album :: operator==(const library :: Album &rhs)
{
	if (artist_id == rhs.artist_id) {
		if (name == rhs.name)
			return year == rhs.year;
	}
	return false;
}



/*
 * library :: Genre:  Genre tag information
 */

library :: Genre :: Genre()
	 : name("")
{
}

library :: Genre :: Genre(TagLib :: Tag *tag)
	 : name(tag->genre().to8Bit(true))
{
}

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

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

#ifdef CONFIG_DEBUG
void library :: Genre :: print()
{
	:: print("Genre: %s", name.c_str());
}
#endif /* CONFIG_DEBUG */

bool library :: Genre :: operator==(const library :: Genre &rhs)
{
	return name == rhs.name;
}



/*
 * library :: Library:  Basic information about each directory in the library
 */

library :: Library :: Library()
	 : root_path(""), enabled(false)
{
}

library :: Library :: Library(const std::string &path, bool is_enabled)
	 : root_path(path), enabled(is_enabled)
{
}

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

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

#ifdef CONFIG_DEBUG
void library :: Library :: print()
{
	:: print("%s", root_path.c_str());
	if (enabled == true)
		:: print(" (enabled)");
	else
		:: print(" (disabled)");
}
#endif /* CONFIG_DEBUG */

bool library :: Library :: operator==(library :: Library &rhs)
{
	return root_path == rhs.root_path;
}



/*
 * Internal library functions
 */
static void do_update(unsigned int, const std :: string &);

static void read_tags(unsigned int lib_id, const std :: string &path)
{
	TagLib :: Tag *tag;
	TagLib :: FileRef ref(path.c_str());
	unsigned int artist_id;

	if (ref.isNull()) {
		print("ERROR: Could not read tags for file %s", path.c_str());
		return;
	}

	tag = ref.tag();
	artist_id = artist_db.insert(tag);
	album_db.insert(library :: Album(tag, artist_id));
	genre_db.insert(library :: Genre(tag));
}

static void process_path(unsigned int lib_id, const std :: string &dir,
			 const std :: string &name)
{
	std :: string path = dir + "/" + name;

	if (g_file_test(path.c_str(), G_FILE_TEST_IS_DIR) == true)
		do_update(lib_id, path);
	else
		read_tags(lib_id, path);
}

static void do_update(unsigned int lib_id, const std :: string &path)
{
	GDir *dir;
	const char *name;

	dir = g_dir_open(path.c_str(), 0, NULL);
	if (dir == NULL)
		return;

	name = g_dir_read_name(dir);
	while (name != NULL) {
		process_path(lib_id, path, name);
		name = g_dir_read_name(dir);
	}
}



/*
 * API used by the GUI begins here
 */

void library :: init()
{
	library_db.load();
}

bool library :: add_path(const std::string &dir)
{
	unsigned int id;
	if (g_file_test(dir.c_str(), G_FILE_TEST_IS_DIR) == false)
		return false;

	id = library_db.insert(library :: Library(dir, true));
	library_db.save();
	update_path(id);
	return true;
}

void library :: del_path(unsigned int id)
{
	library_db.remove(id);
	library_db.save();
}

void library :: update_path(unsigned int id)
{
	if (id > library_db.size())
		return;
	if (library_db[id].valid == false)
		return;
	do_update(id, library_db[id].root_path);
}

#ifdef CONFIG_DEBUG
void library :: print_db(DB_Type type)
{
	switch (type) {
	case DB_ALBUM:
		album_db.print();
		break;
	case DB_ARTIST:
		artist_db.print();
		break;
	case DB_GENRE:
		genre_db.print();
		break;
	case DB_LIBRARY:
		library_db.print();
		break;
	default:
		break;
	}
}

void library :: reset()
{
	album_db.clear();
	artist_db.clear();
	genre_db.clear();
	library_db.clear();
}
#endif /* CONFIG_DEBUG */