anna
/
ocarina
1
0
Fork 0
Code Issues 7 Pull Requests Releases Wiki Activity

libsaria: Remove more dead library code 

Signed-off-by: Bryan Schumaker <bjschuma@gmail.com>
This commit is contained in:
Bryan Schumaker 2012-03-24 12:30:51 -04:00
parent fad3019d83
commit 4ef59da4dd
6 changed files with 0 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
libsaria/library/file.cpp
View File

@ -104,42 +104,3 @@ unsigned int schedule_load()
return atoi(paths.back().c_str()) + 1;
}
/*static void do_load()
{
unsigned int size;
InFile in("library.lib");
if (!in.good())
return;
in >> size;
for (unsigned int i = 0; i < size; i++) {
path_list.push_back(libsaria::LibraryPath());
path_list.back().load_file(in);
}
libsaria::library::sort_list();
libsaria::library::refresh();
}*/
namespace libsaria
{
/*void library::load()
{
IOTask *task = new IOTask(do_load);
task->queue_front();
}
void library::save()
{
OutFile out("library.lib");
list<libsaria::LibraryPath>::iterator it;
out << path_list.size() << "\n";
for (it = path_list.begin(); it != path_list.end(); it++)
it->save(out);
}*/
}; /* namespace: libsaria */

86
libsaria/library/library.cpp
View File

@ -6,40 +6,14 @@
#include <libsaria/fs.h>
#include "library.h"
//#include <map>
#include <list>
#include <string>
using namespace std;
/*#include <libsaria/callback.h>
#include <libsaria/library.h>
#include <libsaria/playlist.h>
#include <libsaria/stack.h>*/
static unsigned int next_id = 0;
static list<struct libsaria::library::Path> path_list;
static list<libsaria::library::Driver *> driver_list;
libsaria::Set lib_playlist("Library", PL_STATIC);
/*list<libsaria::LibraryPath> path_list;
libsaria::Playlist lib_playlist(PL_RANDOM | PL_SEQUENTIAL | PL_FILTER);
static map<sid_t, libsaria::Track *> lookup_map;
void library_map_track(libsaria::Track *track)
{
lookup_map[track->get_songid()] = track;
}
void library_unmap_track(libsaria::Track *track)
{
lookup_map.erase(track->get_songid());
}
static void do_update(libsaria::LibraryPath *path):
{
path->validate();
path->update();
}
*/
void notify_path_updated(libsaria::library::Path *path)
{
@ -101,64 +75,4 @@ namespace libsaria
stack::push(&lib_playlist);
}
/* void library::for_each_path(void (*info_func)(struct library::PathInfo &))
{
list<LibraryPath>::iterator it;
for (it = path_list.begin(); it != path_list.end(); it++)
it->get_info(info_func);
}
void library::update()
{
pathiter::reset();
while (!pathiter::end())
do_update(pathiter::next());
}
void library::update_path(string dir)
{
LibraryPath *path;
pathiter::reset();
while (!pathiter::end()) {
path = pathiter::next();
if (path->get_path() == dir)
do_update(path);
}
}
void library::refresh()
{
trigger_callback(LIBRARY_REFRESH);
}
void library::remove_path(string dir)
{
list<LibraryPath>::iterator it;
for (it = path_list.begin(); it != path_list.end(); it++) {
if (it->get_path() == dir) {
it->prepare_for_removal();
path_list.erase(it);
save();
refresh();
return;
}
}
}
Track *library::lookup(sid_t &sid)
{
map<sid_t, Track *>::iterator it;
it = lookup_map.find(sid);
if (it == lookup_map.end())
return NULL;
return it->second;
}
Playlist *library::get_playlist()
{
return &lib_playlist;
}
*/
}; /* namespace: libsaria */

17
libsaria/library/library.h
View File

@ -11,22 +11,5 @@ void notify_path_updated(struct libsaria::library::Path *);
void save_path(struct libsaria::library::Path *);
libsaria::library::Path *push_path(libsaria::library::Path &);
unsigned int schedule_load();
/*#include <string>
using namespace std;
*/
/*struct LibraryPath {
string path;
};*/
/*#include <list>
using namespace std;
#include <libsaria/libpath.h>
#include <libsaria/playlist.h>
extern list<libsaria::LibraryPath> path_list;
extern libsaria::Playlist lib_playlist;
void library_map_track(libsaria::Track *);
void library_unmap_track(libsaria::Track *);*/
#endif /* LIBSARIA_LIBRARY_SOURCE_H */

32
libsaria/library/path/file.cpp
View File

@ -1,32 +0,0 @@
// Copyright (c) 2011 Bryan Schumaker.
#include <libsaria/libpath.h>
#include "../library.h"
namespace libsaria
{
/* void LibraryPath::load_file(InFile &in)
{
unsigned int size;
libsaria::Track *track;
in >> path;
in >> size;
println("Library path dir: " + path);
println("Library path size: %d", size);
for (unsigned int i = 0; i < size; i++) {
track = new libsaria::Track(in);
file_list.push_back(track);
}
}
void LibraryPath::save(OutFile &out)
{
list<libsaria::Track *>::iterator it;
out << path << file_list.size() << "\n";
for (it = file_list.begin(); it != file_list.end(); it++)
(*it)->save(out);
}*/
}; /* Namespace: libsaria */

61
libsaria/library/path/path.cpp
View File

@ -1,61 +0,0 @@
// Copyright (c) 2011 Bryan Schumaker.
#include <libsaria/libpath.h>
#include <string>
using namespace std;
namespace libsaria
{
LibraryPath::LibraryPath()
{
}
LibraryPath::LibraryPath(string dir)
{
path = dir;
}
LibraryPath::~LibraryPath()
{
list<libsaria::Track *>::iterator it;
for (it = file_list.begin(); it != file_list.end(); it++)
delete (*it);
}
void LibraryPath::prepare_for_removal()
{
list<libsaria::Track *>::iterator it;
// for (it = file_list.begin(); it != file_list.end(); it++)
// (*it)->do_cleanup();
}
string LibraryPath::get_path()
{
return path;
}
unsigned int LibraryPath::get_size()
{
return file_list.size();
}
/*void LibraryPath::get_info(void (*info_func)(struct libsaria::library::PathInfo &))
{
struct libsaria::library::PathInfo info;
info.path = path;
info.size = file_list.size();
info_func(info);
}*/
/* bool LibraryPath::has_id(sid_t id)
{
list<libsaria::Track *>::iterator it;
for (it = file_list.begin(); it != file_list.end(); it++) {
if ((*it)->get_songid() == id)
return true;
}
return false;
}*/
} /* Namespace: libsaria */

154
libsaria/library/path/update.cpp
View File

@ -1,154 +0,0 @@
// Copyright (c) 2011 Bryan Schumaker.
#include <libsaria/path.h>
#include <libsaria/task.h>
#include <libsaria/index.h>
#include <libsaria/libpath.h>
#include <libsaria/print.h>
#include <dirent.h>
#include <list>
using namespace std;
#define MAX_SCAN 25
/*
class ScanTask : public IdleTask
{
private:
libsaria::LibraryPath *lib_path;
list<pair<string, sid_t> > files;
public:
ScanTask(libsaria::LibraryPath *path)
{
lib_path = path;
}
~ScanTask() {};
unsigned int add_file(string &file, sid_t &sid)
{
files.push_back(pair<string, sid_t>(file, sid));
return files.size();
};
void run_task();
};
class ReaddirTask : public IdleTask
{
private:
libsaria::LibraryPath *lib_path;
ScanTask *read_dir(string, ScanTask *);
public:
ReaddirTask(libsaria::LibraryPath *path)
{
lib_path = path;
};
~ReaddirTask() {};
void run_task();
};
static ScanTask *scandir(string dir, libsaria::LibraryPath *lib_path, ScanTask *scan);
void ScanTask::run_task()
{
list<pair<string, sid_t> >::iterator it;
//IOTask *save;
bool dirty = false;
for (it = files.begin(); it != files.end(); it++) {
try {
if (lib_path->add_track(it->first, it->second))
dirty = true;
} catch (string message) {
println(message);
}
}
if (dirty) {
*//* Save the library */
/*save = new IOTask(libsaria::library::save);
save->queue_front();*/
/* Bookkeeping for the UI */
/*libsaria::library::sort_list();
libsaria::index::refresh();
libsaria::library::refresh();*/
/*}
}
static inline ScanTask *scan_entry(struct dirent *dirp,
libsaria::LibraryPath *lib_path,
string &dir,
ScanTask *scan)
{
string name;
if (dirp == NULL)
return scan;
name = dirp->d_name;
if (name == "." || name == "..")
return scan;
name = dir + "/" + name;
switch(dirp->d_type) {
case DT_DIR:
scan = scandir(name, lib_path, scan);
break;
default:
if (scan->add_file(name, dirp->d_ino) > MAX_SCAN) {
scan->queue();
scan = new ScanTask(lib_path);
}
}
return scan;
}
static ScanTask *scandir(string dir, libsaria::LibraryPath *lib_path, ScanTask *scan)
{
DIR *dp;
struct dirent *dirp;
dp = opendir(dir.c_str());
if (dp == NULL)
return scan;
do {
dirp = readdir(dp);
scan = scan_entry(dirp, lib_path, dir, scan);
} while (dirp != NULL);
closedir (dp);
return scan;
}
void ReaddirTask::run_task()
{
class ScanTask *scan = new ScanTask(lib_path);
scan = scandir(lib_path->get_path(), lib_path, scan);
scan->queue();
}
*/
namespace libsaria
{
/*bool LibraryPath::add_track(string &filepath, sid_t &songid)
{
libsaria::Track *track;
if (has_id(songid) == false) {
track = new libsaria::Track(filepath, songid);
file_list.push_back(track);
return true;
}
return false;
}*/
void LibraryPath::update()
{
/* ReaddirTask *task = new ReaddirTask(this);
task->queue();*/
}
} /* Namespace: libsaria */