mirror/musikcube
1
0
Fork 0
mirror of https://github.com/clangen/musikcube.git synced 2025-03-29 19:20:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

SDK naming cleanup:

Browse Source 
New interface: IResource
IMetadataValue -> IValue : public IResource
IMetadataValueList -> IValueList
IMetadataMap -> IMap : public IResource
IMetadataMapList -> IMapList
IMetadataReader -> ITagReader
ITrackWriter -> ITrackStore
This commit is contained in:
casey langen 2017-10-01 12:52:10 -07:00
parent 41c4f9bbf1
commit fddb7ca114
49 changed files with 324 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/core/audio/PlaybackService.cpp
View File

@ -705,7 +705,7 @@ double PlaybackService::GetDuration() {
if (track) {
return boost::lexical_cast<double>(
track->GetValue(constants::Track::DURATION));
track->GetString(constants::Track::DURATION));
}
return 0.0f;

13
src/core/core.vcxproj
View File

@ -200,11 +200,12 @@
<ClInclude Include="sdk\IIndexerNotifier.h" />
<ClInclude Include="sdk\IIndexerSource.h" />
<ClInclude Include="sdk\IIndexerWriter.h" />
<ClInclude Include="sdk\IMetadataMap.h" />
<ClInclude Include="sdk\IMetadataMapList.h" />
<ClInclude Include="sdk\IMetadataReader.h" />
<ClInclude Include="sdk\IMetadataValue.h" />
<ClInclude Include="sdk\IMetadataValueList.h" />
<ClInclude Include="sdk\IMap.h" />
<ClInclude Include="sdk\IMapList.h" />
<ClInclude Include="sdk\ITagReader.h" />
<ClInclude Include="sdk\IResource.h" />
<ClInclude Include="sdk\IValue.h" />
<ClInclude Include="sdk\IValueList.h" />
<ClInclude Include="sdk\IOutput.h" />
<ClInclude Include="sdk\IBufferProvider.h" />
<ClInclude Include="sdk\IPcmVisualizer.h" />
@ -225,7 +226,7 @@
<ClInclude Include="sdk\ITrack.h" />
<ClInclude Include="sdk\ITrackList.h" />
<ClInclude Include="sdk\ITrackListEditor.h" />
<ClInclude Include="sdk\ITrackWriter.h" />
<ClInclude Include="sdk\ITagStore.h" />
<ClInclude Include="sdk\IVisualizer.h" />
<ClInclude Include="support\Common.h" />
<ClInclude Include="support\PreferenceKeys.h" />

39
src/core/core.vcxproj.filters
View File

@ -423,9 +423,6 @@
<ClInclude Include="sdk\IPlaybackRemote.h">
<Filter>src\sdk\audio</Filter>
</ClInclude>
<ClInclude Include="sdk\IMetadataReader.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\IPlaybackService.h">
<Filter>src\sdk\audio</Filter>
</ClInclude>
@ -441,9 +438,6 @@
<ClInclude Include="sdk\IIndexerWriter.h">
<Filter>src\sdk\indexer</Filter>
</ClInclude>
<ClInclude Include="sdk\ITrackWriter.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\ITrackListEditor.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
@ -459,20 +453,29 @@
<ClInclude Include="sdk\IRetainedTrack.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\IMetadataMap.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\IMetadataMapList.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\IMetadataValue.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\IMetadataValueList.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\IDevice.h">
<Filter>src\sdk\audio</Filter>
</ClInclude>
<ClInclude Include="sdk\IValue.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\IValueList.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\IResource.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\IMap.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\IMapList.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\ITagReader.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
<ClInclude Include="sdk\ITagStore.h">
<Filter>src\sdk\library</Filter>
</ClInclude>
</ItemGroup>
</Project>

16
src/core/library/Indexer.cpp
View File

@ -80,7 +80,7 @@ using namespace musik::core::library;
using Thread = std::unique_ptr<boost::thread>;
using MetadataDeleter = PluginFactory::DestroyDeleter<IMetadataReader>;
using TagReaderDestroyer = PluginFactory::DestroyDeleter<ITagReader>;
using DecoderDeleter = PluginFactory::DestroyDeleter<IDecoderFactory>;
using SourceDeleter = PluginFactory::DestroyDeleter<IIndexerSource>;
@ -128,8 +128,8 @@ Indexer::Indexer(const std::string& libraryPath, const std::string& dbFilename)
openLogFile();
}
this->metadataReaders = PluginFactory::Instance()
.QueryInterface<IMetadataReader, MetadataDeleter>("GetMetadataReader");
this->tagReaders = PluginFactory::Instance()
.QueryInterface<ITagReader, TagReaderDestroyer>("GetTagReader");
this->audioDecoders = PluginFactory::Instance()
.QueryInterface<IDecoderFactory, DecoderDeleter>("GetDecoderFactory");
@ -364,11 +364,11 @@ void Indexer::ReadMetadataFromFile(
bool saveToDb = false;
/* read the tag from the plugin */
typedef MetadataReaderList::iterator Iterator;
Iterator it = this->metadataReaders.begin();
while (it != this->metadataReaders.end()) {
typedef TagReaderList::iterator Iterator;
Iterator it = this->tagReaders.begin();
while (it != this->tagReaders.end()) {
try {
if ((*it)->CanRead(track.GetValue("extension").c_str())) {
if ((*it)->CanRead(track.GetString("extension").c_str())) {
if (logFile) {
fprintf(logFile, " - %s\n", file.string().c_str());
}
@ -531,7 +531,7 @@ ScanResult Indexer::SyncSource(IIndexerSource* source) {
track->SetValue(constants::Track::FILENAME, tracks.ColumnText(1));
if (logFile) {
fprintf(logFile, " - %s\n", track->GetValue(constants::Track::FILENAME).c_str());
fprintf(logFile, " - %s\n", track->GetString(constants::Track::FILENAME).c_str());
}
source->ScanTrack(this, new RetainedTrackWriter(track), tracks.ColumnText(2));

6
src/core/library/Indexer.h
View File

@ -35,7 +35,7 @@
#pragma once
#include <core/db/Connection.h>
#include <core/sdk/IMetadataReader.h>
#include <core/sdk/ITagReader.h>
#include <core/sdk/IDecoderFactory.h>
#include <core/sdk/IIndexerWriter.h>
#include <core/sdk/IIndexerNotifier.h>
@ -103,7 +103,7 @@ namespace musik { namespace core {
};
typedef std::vector<std::shared_ptr<
musik::core::sdk::IMetadataReader> > MetadataReaderList;
musik::core::sdk::ITagReader> > TagReaderList;
typedef std::vector<std::shared_ptr<
musik::core::sdk::IDecoderFactory> > DecoderList;
@ -150,7 +150,7 @@ namespace musik { namespace core {
std::atomic<size_t> tracksScanned;
std::deque<AddRemoveContext> addRemoveQueue;
std::deque<SyncContext> syncQueue;
MetadataReaderList metadataReaders;
TagReaderList tagReaders;
DecoderList audioDecoders;
IndexerSourceList sources;
std::shared_ptr<musik::core::Preferences> prefs;

6
src/core/library/LocalSimpleDataProvider.cpp
View File

@ -219,7 +219,7 @@ ITrackList* LocalSimpleDataProvider::QueryTracksByCategory(
return nullptr;
}
IMetadataValueList* LocalSimpleDataProvider::QueryCategory(const char* type, const char* filter) {
IValueList* LocalSimpleDataProvider::QueryCategory(const char* type, const char* filter) {
try {
std::shared_ptr<CategoryListQuery> search(
new CategoryListQuery(type, std::string(filter ? filter : "")));
@ -237,7 +237,7 @@ IMetadataValueList* LocalSimpleDataProvider::QueryCategory(const char* type, con
return nullptr;
}
IMetadataMapList* LocalSimpleDataProvider::QueryAlbums(
IMapList* LocalSimpleDataProvider::QueryAlbums(
const char* categoryIdName,
int64_t categoryIdValue,
const char* filter)
@ -261,7 +261,7 @@ IMetadataMapList* LocalSimpleDataProvider::QueryAlbums(
return nullptr;
}
IMetadataMapList* LocalSimpleDataProvider::QueryAlbums(const char* filter) {
IMapList* LocalSimpleDataProvider::QueryAlbums(const char* filter) {
return this->QueryAlbums(nullptr, -1, filter);
}

6
src/core/library/LocalSimpleDataProvider.h
View File

@ -65,15 +65,15 @@ namespace musik { namespace core { namespace db { namespace local {
int limit = -1,
int offset = 0) override;
virtual musik::core::sdk::IMetadataValueList*
virtual musik::core::sdk::IValueList*
QueryCategory(
const char* type,
const char* filter = "") override;
virtual musik::core::sdk::IMetadataMapList*
virtual musik::core::sdk::IMapList*
QueryAlbums(const char* filter = "") override;
virtual musik::core::sdk::IMetadataMapList* QueryAlbums(
virtual musik::core::sdk::IMapList* QueryAlbums(
const char* categoryIdName,
int64_t categoryIdValue,
const char* filter = "") override;

27
src/core/library/metadata/MetadataMap.cpp
View File

@ -51,28 +51,29 @@ namespace {
can pass this to a plugin and it will keep the instance
around until it's released, even if the containing list is
released. */
class SdkWrapper : public IMetadataMap {
class SdkWrapper : public IMap {
public:
SdkWrapper(MetadataMapPtr wrapped) { this->wrapped = wrapped; };
virtual void Release() { this->wrapped.reset(); }
virtual int64_t GetId() { return this->wrapped->GetId(); }
virtual int GetValue(const char* key, char* dst, int size) { return this->wrapped->GetValue(key, dst, size); }
virtual ResourceType GetResourceType() { return this->wrapped->GetResourceType(); }
virtual int GetString(const char* key, char* dst, int size) { return this->wrapped->GetString(key, dst, size); }
virtual long long GetInt64(const char* key, long long defaultValue) { return this->wrapped->GetInt64(key, defaultValue); }
virtual int GetInt32(const char* key, unsigned int defaultValue) { return this->wrapped->GetInt32(key, defaultValue); }
virtual double GetDouble(const char* key, double defaultValue) { return this->wrapped->GetDouble(key, defaultValue); }
virtual const char* GetDescription() { return this->wrapped->GetDescription(); }
virtual const char* GetType() { return this->wrapped->GetType(); }
virtual int GetValue(char* dst, size_t size) { return this->wrapped->GetValue(dst, size); }
virtual const char* GetDataType() { return this->wrapped->GetDataType(); }
MetadataMapPtr wrapped;
};
}
MetadataMap::MetadataMap(
int64_t id,
const std::string& description,
const std::string& value,
const std::string& type)
{
this->id = id;
this->description = description;
this->value = value;
this->type = type;
}
@ -88,7 +89,11 @@ int64_t MetadataMap::GetId() {
return this->id;
}
int MetadataMap::GetValue(const char* key, char* dst, int size) {
ResourceType MetadataMap::GetResourceType() {
return ResourceType::Map;
}
int MetadataMap::GetString(const char* key, char* dst, int size) {
auto it = metadata.find(key);
if (it != metadata.end()) {
return CopyString(it->second, dst, size);
@ -145,11 +150,11 @@ double MetadataMap::GetDouble(const char* key, double defaultValue) {
return defaultValue;
}
const char* MetadataMap::GetDescription() {
return this->description.c_str();
int MetadataMap::GetValue(char* dst, size_t size) {
return CopyString(this->value, dst, size);
}
const char* MetadataMap::GetType() {
const char* MetadataMap::GetDataType() {
return this->type.c_str();
}
@ -157,6 +162,6 @@ void MetadataMap::SetValue(const char* key, const std::string& value) {
this->metadata[key] = value;
}
musik::core::sdk::IMetadataMap* MetadataMap::GetSdkValue() {
musik::core::sdk::IMap* MetadataMap::GetSdkValue() {
return new SdkWrapper(shared_from_this());
}

24
src/core/library/metadata/MetadataMap.h
View File

@ -34,7 +34,7 @@
#pragma once
#include <core/sdk/IMetadataMap.h>
#include <core/sdk/IMap.h>
#include <string>
#include <unordered_map>
#include <memory>
@ -42,36 +42,40 @@
namespace musik { namespace core {
class MetadataMap :
public musik::core::sdk::IMetadataMap,
public musik::core::sdk::IMap,
public std::enable_shared_from_this<MetadataMap>
{
public:
MetadataMap(
int64_t id,
const std::string& description,
const std::string& value,
const std::string& type);
virtual ~MetadataMap();
/* IMetadataMap */
virtual void Release();
/* IResource */
virtual int64_t GetId();
virtual const char* GetDescription();
virtual const char* GetType();
virtual musik::core::sdk::ResourceType GetResourceType();
virtual int GetValue(const char* key, char* dst, int size);
/* IValue */
virtual int GetValue(char* dst, size_t size);
/* IMap */
virtual void Release();
virtual int GetString(const char* key, char* dst, int size);
virtual long long GetInt64(const char* key, long long defaultValue = 0LL);
virtual int GetInt32(const char* key, unsigned int defaultValue = 0);
virtual double GetDouble(const char* key, double defaultValue = 0.0f);
virtual const char* GetDataType();
/* implementation specific */
void SetValue(const char* key, const std::string& value);
std::string GetValue(const char* key);
musik::core::sdk::IMetadataMap* GetSdkValue();
musik::core::sdk::IMap* GetSdkValue();
private:
int64_t id;
std::string type, description;
std::string type, value;
std::unordered_map<std::string, std::string> metadata;
};

12
src/core/library/metadata/MetadataMapList.cpp
View File

@ -39,12 +39,12 @@ using namespace musik::core;
using namespace musik::core::sdk;
namespace {
class SdkWrapper : public IMetadataMapList {
class SdkWrapper : public IMapList {
public:
SdkWrapper(MetadataMapListPtr wrapped) { this->wrapped = wrapped; }
virtual void Release() { this->wrapped.reset(); }
virtual size_t Count() const { return this->wrapped->Count(); }
virtual IMetadataMap* GetMetadata(size_t index) const { return this->wrapped->GetMetadata(index); }
virtual IMap* GetAt(size_t index) const { return this->wrapped->GetAt(index); }
MetadataMapListPtr wrapped;
};
}
@ -65,7 +65,7 @@ size_t MetadataMapList::Count() const {
return this->entries.size();
}
IMetadataMap* MetadataMapList::GetMetadata(size_t index) const {
IMap* MetadataMapList::GetAt(size_t index) const {
return this->entries.at(index)->GetSdkValue();
}
@ -73,10 +73,6 @@ void MetadataMapList::Add(MetadataMapPtr entry) {
this->entries.push_back(entry);
}
MetadataMapPtr MetadataMapList::Get(size_t index) {
return this->entries.at(index);
}
IMetadataMapList* MetadataMapList::GetSdkValue() {
IMapList* MetadataMapList::GetSdkValue() {
return new SdkWrapper(shared_from_this());
}

11
src/core/library/metadata/MetadataMapList.h
View File

@ -34,7 +34,7 @@
#pragma once
#include <core/sdk/IMetadataMapList.h>
#include <core/sdk/IMapList.h>
#include "MetadataMap.h"
#include <vector>
#include <memory>
@ -42,22 +42,21 @@
namespace musik { namespace core {
class MetadataMapList :
public musik::core::sdk::IMetadataMapList,
public musik::core::sdk::IMapList,
public std::enable_shared_from_this<MetadataMapList>
{
public:
MetadataMapList();
virtual ~MetadataMapList();
/* IMetadataMapList */
/* IMapList */
virtual void Release();
virtual size_t Count() const;
virtual musik::core::sdk::IMetadataMap* GetMetadata(size_t index) const;
virtual musik::core::sdk::IMap* GetAt(size_t index) const;
/* implementation specific */
void Add(MetadataMapPtr entry);
MetadataMapPtr Get(size_t index);
musik::core::sdk::IMetadataMapList* GetSdkValue();
musik::core::sdk::IMapList* GetSdkValue();
private:
std::vector<MetadataMapPtr> entries;

6
src/core/library/query/local/AlbumListQuery.cpp
View File

@ -109,7 +109,7 @@ MetadataMapListPtr AlbumListQuery::GetResult() {
return this->result;
}
musik::core::sdk::IMetadataMapList* AlbumListQuery::GetSdkResult() {
musik::core::sdk::IMapList* AlbumListQuery::GetSdkResult() {
return this->result->GetSdkValue();
}
@ -148,9 +148,7 @@ bool AlbumListQuery::OnRun(Connection& db) {
while (stmt.Step() == Row) {
std::shared_ptr<MetadataMap> row(new MetadataMap(
stmt.ColumnInt64(0),
stmt.ColumnText(1),
"album"));
stmt.ColumnInt64(0), stmt.ColumnText(1), "album"));
row->SetValue(Track::ALBUM_ARTIST_ID, stmt.ColumnText(2));
row->SetValue(Track::ALBUM_ARTIST, stmt.ColumnText(3));

2
src/core/library/query/local/AlbumListQuery.h
View File

@ -55,7 +55,7 @@ namespace musik { namespace core { namespace db { namespace local {
std::string Name() { return "AlbumListQuery"; }
musik::core::MetadataMapListPtr GetResult();
musik::core::sdk::IMetadataMapList* GetSdkResult();
musik::core::sdk::IMapList* GetSdkResult();
protected:
virtual bool OnRun(musik::core::db::Connection &db);

10
src/core/library/query/local/CategoryListQuery.cpp
View File

@ -126,9 +126,9 @@ static std::map<std::string, std::string> FILTERED_FIELD_TO_QUERY_MAP = {
};
/* data structure that we can return to plugins who need metadata info */
class MetadataList : public musik::core::sdk::IMetadataValueList {
class ValueList : public musik::core::sdk::IValueList {
public:
MetadataList(CategoryListQuery::ResultList results) {
ValueList(CategoryListQuery::ResultList results) {
this->results = results;
}
@ -140,7 +140,7 @@ class MetadataList : public musik::core::sdk::IMetadataValueList {
return this->results->size();
}
virtual musik::core::sdk::IMetadataValue* GetAt(size_t index) {
virtual musik::core::sdk::IValue* GetAt(size_t index) {
return this->results->at(index).get();
}
@ -167,8 +167,8 @@ CategoryListQuery::ResultList CategoryListQuery::GetResult() {
return this->result;
}
musik::core::sdk::IMetadataValueList* CategoryListQuery::GetSdkResult() {
return new MetadataList(this->result);
musik::core::sdk::IValueList* CategoryListQuery::GetSdkResult() {
return new ValueList(this->result);
}
int CategoryListQuery::GetIndexOf(int64_t id) {

10
src/core/library/query/local/CategoryListQuery.h
View File

@ -36,7 +36,7 @@
#include <core/library/query/local/LocalQueryBase.h>
#include <core/db/Connection.h>
#include <core/sdk/IMetadataValueList.h>
#include <core/sdk/IValueList.h>
#include <core/support/Common.h>
#include <memory>
@ -46,13 +46,13 @@ namespace musik { namespace core { namespace db { namespace local {
public:
/* note we implement the SDK's IMetadataValue interface so
we can return data to plugins! */
struct Result : public musik::core::sdk::IMetadataValue {
struct Result : public musik::core::sdk::IValue {
virtual int64_t GetId() {
return this->id;
}
virtual const char* GetValue() {
return this->displayValue.c_str();
virtual musik::core::sdk::ResourceType GetResourceType() {
return musik::core::sdk::ResourceType::Value;
}
virtual int GetValue(char* dst, size_t size) {
@ -77,7 +77,7 @@ namespace musik { namespace core { namespace db { namespace local {
virtual ResultList GetResult();
virtual int GetIndexOf(int64_t id);
musik::core::sdk::IMetadataValueList* GetSdkResult();
musik::core::sdk::IValueList* GetSdkResult();
protected:
virtual bool OnRun(musik::core::db::Connection &db);

4
src/core/library/query/local/SavePlaylistQuery.cpp
View File

@ -205,8 +205,8 @@ bool SavePlaylistQuery::AddTracksToPlaylist(
track = tracks->Get(i);
if (track) {
insertTrack.Reset();
insertTrack.BindText(0, track->GetValue("external_id"));
insertTrack.BindText(1, track->GetValue("source_id"));
insertTrack.BindText(0, track->GetString("external_id"));
insertTrack.BindText(1, track->GetString("source_id"));
insertTrack.BindInt64(2, playlistId);
insertTrack.BindInt32(3, offset++);

2
src/core/library/query/local/TrackMetadataQuery.cpp
View File

@ -73,7 +73,7 @@ bool TrackMetadataQuery::OnRun(Connection& db) {
trackQuery.BindInt64(0, (int64_t) this->result->GetId());
}
else {
const std::string& externalId = this->result->GetValue("external_id");
const std::string& externalId = this->result->GetString("external_id");
if (!externalId.size()) {
return false;
}

70
src/core/library/track/IndexerTrack.cpp
View File

@ -75,7 +75,7 @@ IndexerTrack::~IndexerTrack() {
this->internalMetadata = nullptr;
}
std::string IndexerTrack::GetValue(const char* metakey) {
std::string IndexerTrack::GetString(const char* metakey) {
if (metakey && this->internalMetadata) {
MetadataMap::iterator metavalue = this->internalMetadata->metadata.find(metakey);
if (metavalue != this->internalMetadata->metadata.end()) {
@ -88,9 +88,9 @@ std::string IndexerTrack::GetValue(const char* metakey) {
long long IndexerTrack::GetInt64(const char* key, long long defaultValue) {
try {
std::string value = GetValue(key);
std::string value = GetString(key);
if (value.size()) {
return std::stoll(GetValue(key));
return std::stoll(GetString(key));
}
} catch (...) {
}
@ -99,9 +99,9 @@ long long IndexerTrack::GetInt64(const char* key, long long defaultValue) {
int IndexerTrack::GetInt32(const char* key, unsigned int defaultValue) {
try {
std::string value = GetValue(key);
std::string value = GetString(key);
if (value.size()) {
return std::stol(GetValue(key));
return std::stol(GetString(key));
}
}
catch (...) {
@ -111,9 +111,9 @@ int IndexerTrack::GetInt32(const char* key, unsigned int defaultValue) {
double IndexerTrack::GetDouble(const char* key, double defaultValue) {
try {
std::string value = GetValue(key);
std::string value = GetString(key);
if (value.size()) {
return std::stod(GetValue(key));
return std::stod(GetString(key));
}
} catch (...) {
}
@ -145,11 +145,11 @@ void IndexerTrack::SetThumbnail(const char *data, long size) {
}
std::string IndexerTrack::Uri() {
return this->GetValue("filename");
return this->GetString("filename");
}
int IndexerTrack::GetValue(const char* key, char* dst, int size) {
return CopyString(this->GetValue(key), dst, size);
int IndexerTrack::GetString(const char* key, char* dst, int size) {
return CopyString(this->GetString(key), dst, size);
}
int IndexerTrack::Uri(char* dst, int size) {
@ -202,7 +202,7 @@ bool IndexerTrack::NeedsToBeIndexed(
"FROM tracks t " \
"WHERE filename=?", dbConnection);
stmt.BindText(0, this->GetValue("filename"));
stmt.BindText(0, this->GetString("filename"));
bool fileDifferent = true;
@ -226,7 +226,7 @@ static int64_t writeToTracksTable(
db::Connection &dbConnection,
IndexerTrack& track)
{
std::string externalId = track.GetValue("external_id");
std::string externalId = track.GetString("external_id");
int64_t id = track.GetId();
if (externalId.size() == 0) {
@ -248,10 +248,10 @@ static int64_t writeToTracksTable(
}
}
else {
std::string fn = track.GetValue("filename");
std::string fn = track.GetString("filename");
if (fn.size()) {
db::Statement stmt("SELECT id, external_id FROM tracks WHERE filename=?", dbConnection);
stmt.BindText(0, track.GetValue("filename"));
stmt.BindText(0, track.GetString("filename"));
if (stmt.Step() == db::Row) {
id = stmt.ColumnInt64(0);
track.SetId(id);
@ -279,17 +279,17 @@ static int64_t writeToTracksTable(
db::Statement stmt(query.c_str(), dbConnection);
stmt.BindText(0, track.GetValue("track"));
stmt.BindText(1, track.GetValue("disc"));
stmt.BindText(2, track.GetValue("bpm"));
stmt.BindText(0, track.GetString("track"));
stmt.BindText(1, track.GetString("disc"));
stmt.BindText(2, track.GetString("bpm"));
stmt.BindInt32(3, track.GetInt32("duration"));
stmt.BindInt32(4, track.GetInt32("filesize"));
stmt.BindText(5, track.GetValue("year"));
stmt.BindText(6, track.GetValue("title"));
stmt.BindText(7, track.GetValue("filename"));
stmt.BindText(5, track.GetString("year"));
stmt.BindText(6, track.GetString("title"));
stmt.BindText(7, track.GetString("filename"));
stmt.BindInt32(8, track.GetInt32("filetime"));
stmt.BindInt64(9, track.GetInt64("path_id"));
stmt.BindText(10, track.GetValue("external_id"));
stmt.BindText(10, track.GetString("external_id"));
if (id != 0) {
stmt.BindInt64(11, id);
@ -486,22 +486,22 @@ static size_t hash32(const char* str) {
}
static std::string createTrackExternalId(IndexerTrack& track) {
size_t hash1 = (size_t) hash32(track.GetValue("filename").c_str());
size_t hash1 = (size_t) hash32(track.GetString("filename").c_str());
size_t hash2 = (size_t) hash32(
(track.GetValue("title") +
track.GetValue("album") +
track.GetValue("artist") +
track.GetValue("album_artist") +
track.GetValue("filesize") +
track.GetValue("duration")).c_str());
(track.GetString("title") +
track.GetString("album") +
track.GetString("artist") +
track.GetString("album_artist") +
track.GetString("filesize") +
track.GetString("duration")).c_str());
return std::string("local-") + std::to_string(hash1) + "-" + std::to_string(hash2);
}
int64_t IndexerTrack::SaveAlbum(db::Connection& dbConnection) {
std::string album = this->GetValue("album");
std::string value = album + "-" + this->GetValue("album_artist");
std::string album = this->GetString("album");
std::string value = album + "-" + this->GetString("album_artist");
/* ideally we'd use std::hash<>, but on some platforms this returns a 64-bit
unsigned number, which cannot be easily used with sqlite3. */
@ -536,7 +536,7 @@ int64_t IndexerTrack::SaveSingleValueField(
"SELECT id FROM %1% WHERE name=?") % fieldTableName);
db::Statement stmt(selectQuery.c_str(), dbConnection);
std::string value = this->GetValue(trackMetadataKeyName.c_str());
std::string value = this->GetString(trackMetadataKeyName.c_str());
if (metadataIdCache.find(fieldTableName + "-" + value) != metadataIdCache.end()) {
id = metadataIdCache[fieldTableName + "-" + value];
@ -636,11 +636,11 @@ int64_t IndexerTrack::SaveArtist(db::Connection& dbConnection) {
bool IndexerTrack::Save(db::Connection &dbConnection, std::string libraryDirectory) {
std::unique_lock<std::mutex> lock(sharedWriteMutex);
if (this->GetValue("album_artist") == "") {
this->SetValue("album_artist", this->GetValue("artist").c_str());
if (this->GetString("album_artist") == "") {
this->SetValue("album_artist", this->GetString("artist").c_str());
}
if (this->GetValue("external_id") == "") {
if (this->GetString("external_id") == "") {
this->SetValue("external_id", createTrackExternalId(*this).c_str());
}
@ -666,7 +666,7 @@ bool IndexerTrack::Save(db::Connection &dbConnection, std::string libraryDirecto
int sourceId = 0;
try {
std::string source = this->GetValue("source_id");
std::string source = this->GetString("source_id");
if (source.size()) {
sourceId = std::stoi(source.c_str());
}

4
src/core/library/track/IndexerTrack.h
View File

@ -51,8 +51,8 @@ namespace musik { namespace core {
virtual void SetThumbnail(const char *data, long size);
/* ITrack */
virtual std::string GetValue(const char* metakey);
virtual int GetValue(const char* key, char* dst, int size);
virtual std::string GetString(const char* metakey);
virtual int GetString(const char* key, char* dst, int size);
virtual long long GetInt64(const char* key, long long defaultValue = 0LL);
virtual int GetInt32(const char* key, unsigned int defaultValue = 0);
virtual double GetDouble(const char* key, double defaultValue = 0.0f);

22
src/core/library/track/LibraryTrack.cpp
View File

@ -62,7 +62,7 @@ LibraryTrack::LibraryTrack(int64_t id, musik::core::ILibraryPtr library)
LibraryTrack::~LibraryTrack() {
}
std::string LibraryTrack::GetValue(const char* metakey) {
std::string LibraryTrack::GetString(const char* metakey) {
std::unique_lock<std::mutex> lock(this->data.mutex);
MetadataMap::iterator metavalue = this->data.metadata.find(metakey);
if (metavalue != this->data.metadata.end()) {
@ -73,9 +73,9 @@ std::string LibraryTrack::GetValue(const char* metakey) {
long long LibraryTrack::GetInt64(const char* key, long long defaultValue) {
try {
std::string value = GetValue(key);
std::string value = GetString(key);
if (value.size()) {
return std::stoll(GetValue(key));
return std::stoll(GetString(key));
}
}
catch (...) {
@ -85,9 +85,9 @@ long long LibraryTrack::GetInt64(const char* key, long long defaultValue) {
int LibraryTrack::GetInt32(const char* key, unsigned int defaultValue) {
try {
std::string value = GetValue(key);
std::string value = GetString(key);
if (value.size()) {
return std::stol(GetValue(key));
return std::stol(GetString(key));
}
}
catch (...) {
@ -97,9 +97,9 @@ int LibraryTrack::GetInt32(const char* key, unsigned int defaultValue) {
double LibraryTrack::GetDouble(const char* key, double defaultValue) {
try {
std::string value = GetValue(key);
std::string value = GetString(key);
if (value.size()) {
return std::stod(GetValue(key));
return std::stod(GetString(key));
}
}
catch (...) {
@ -126,11 +126,11 @@ void LibraryTrack::SetThumbnail(const char *data, long size) {
}
std::string LibraryTrack::Uri() {
return this->GetValue("filename");
return this->GetString("filename");
}
int LibraryTrack::GetValue(const char* key, char* dst, int size) {
return CopyString(this->GetValue(key), dst, size);
int LibraryTrack::GetString(const char* key, char* dst, int size) {
return CopyString(this->GetString(key), dst, size);
}
int LibraryTrack::Uri(char* dst, int size) {
@ -166,7 +166,7 @@ bool LibraryTrack::Load(Track *target, db::Connection &db) {
/* if no ID is specified, see if we can look one up by filename
in the current database. */
if (target->GetId() == 0) {
std::string path = target->GetValue("filename");
std::string path = target->GetString("filename");
if (!path.size()) {
return false;

4
src/core/library/track/LibraryTrack.h
View File

@ -54,7 +54,7 @@ namespace musik { namespace core {
virtual int64_t GetId();
virtual void SetId(int64_t id) { this->id = id; }
virtual std::string GetValue(const char* metakey);
virtual std::string GetString(const char* metakey);
virtual std::string Uri();
/* IWritableTrack */
@ -66,7 +66,7 @@ namespace musik { namespace core {
virtual long long GetInt64(const char* key, long long defaultValue = 0LL);
virtual int GetInt32(const char* key, unsigned int defaultValue = 0);
virtual double GetDouble(const char* key, double defaultValue = 0.0f);
virtual int GetValue(const char* key, char* dst, int size);
virtual int GetString(const char* key, char* dst, int size);
virtual int Uri(char* dst, int size);
virtual MetadataIteratorRange GetValues(const char* metakey);

4
src/core/library/track/RetainedTrack.cpp
View File

@ -60,8 +60,8 @@ void RetainedTrack::Retain() {
++this->count;
}
int RetainedTrack::GetValue(const char* key, char* dst, int size) {
return track->GetValue(key, dst, size);
int RetainedTrack::GetString(const char* key, char* dst, int size) {
return track->GetString(key, dst, size);
}
int RetainedTrack::Uri(char* dst, int size) {

4
src/core/library/track/RetainedTrack.h
View File

@ -50,7 +50,7 @@ namespace musik { namespace core {
/* ITrack */
virtual int64_t GetId();
virtual int GetValue(const char* key, char* dst, int size);
virtual int GetString(const char* key, char* dst, int size);
virtual long long GetInt64(const char* key, long long defaultValue = 0LL);
virtual int GetInt32(const char* key, unsigned int defaultValue = 0);
virtual double GetDouble(const char* key, double defaultValue = 0.0f);
@ -74,7 +74,7 @@ namespace musik { namespace core {
virtual void Release();
virtual void Retain();
/* ITrackWriter */
/* ITagStore */
virtual void SetValue(const char* metakey, const char* value);
virtual void ClearValue(const char* metakey);
virtual void SetThumbnail(const char *data, long size);

8
src/core/library/track/Track.h
View File

@ -34,7 +34,7 @@
#pragma once
#include <core/sdk/ITrackWriter.h>
#include <core/sdk/ITagStore.h>
#include <core/library/ILibrary.h>
#include <core/sdk/ITrack.h>
#include <boost/shared_ptr.hpp>
@ -48,7 +48,7 @@ namespace musik { namespace core {
typedef std::vector<TrackPtr> TrackVector;
class Track :
public musik::core::sdk::ITrackWriter,
public musik::core::sdk::ITagStore,
public musik::core::sdk::ITrack
{
public:
@ -63,7 +63,7 @@ namespace musik { namespace core {
virtual musik::core::ILibraryPtr Library();
virtual int LibraryId();
virtual std::string GetValue(const char* metakey) = 0;
virtual std::string GetString(const char* metakey) = 0;
virtual std::string Uri() = 0;
/* IWritableTrack */
@ -72,7 +72,7 @@ namespace musik { namespace core {
virtual void SetThumbnail(const char *data, long size) = 0;
/* ITrack */
virtual int GetValue(const char* key, char* dst, int size) = 0;
virtual int GetString(const char* key, char* dst, int size) = 0;
virtual long long GetInt64(const char* key, long long defaultValue = 0LL) = 0;
virtual int GetInt32(const char* key, unsigned int defaultValue = 0) = 0;
virtual double GetDouble(const char* key, double defaultValue = 0.0f) = 0;

8
src/core/sdk/IAnalyzer.h
View File

@ -34,7 +34,7 @@
#pragma once
#include "ITrackWriter.h"
#include "ITagStore.h"
#include "IBuffer.h"
namespace musik { namespace core { namespace sdk {
@ -42,9 +42,9 @@ namespace musik { namespace core { namespace sdk {
class IAnalyzer {
public:
virtual void Destroy() = 0;
virtual bool Start(musik::core::sdk::ITrackWriter *target) = 0;
virtual bool Analyze(musik::core::sdk::ITrackWriter *target, IBuffer *buffer) = 0;
virtual bool End(musik::core::sdk::ITrackWriter *target) = 0;
virtual bool Start(musik::core::sdk::ITagStore *target) = 0;
virtual bool Analyze(musik::core::sdk::ITagStore *target, IBuffer *buffer) = 0;
virtual bool End(musik::core::sdk::ITagStore *target) = 0;
};
} } }

2
src/core/sdk/IIndexerSource.h
View File

@ -36,7 +36,7 @@
#include "constants.h"
#include "IIndexerWriter.h"
#include "ITrackWriter.h"
#include "ITagStore.h"
namespace musik { namespace core { namespace sdk {

10
src/core/sdk/IMetadataMap.h → src/core/sdk/IMap.h
View File

@ -34,20 +34,18 @@
#pragma once
#include "constants.h"
#include "IValue.h"
namespace musik { namespace core { namespace sdk {
class IMetadataMap {
class IMap : public IValue {
public:
virtual void Release() = 0;
virtual int64_t GetId() = 0;
virtual int GetValue(const char* key, char* dst, int size) = 0;
virtual int GetString(const char* key, char* dst, int size) = 0;
virtual long long GetInt64(const char* key, long long defaultValue = 0LL) = 0;
virtual int GetInt32(const char* key, unsigned int defaultValue = 0) = 0;
virtual double GetDouble(const char* key, double defaultValue = 0.0f) = 0;
virtual const char* GetDescription() = 0;
virtual const char* GetType() = 0;
virtual const char* GetDataType() = 0;
};
} } }

6
src/core/sdk/IMetadataMapList.h → src/core/sdk/IMapList.h
View File

@ -34,16 +34,16 @@
#pragma once
#include "IMetadataMap.h"
#include "IMap.h"
#include <stddef.h>
namespace musik { namespace core { namespace sdk {
class IMetadataMapList {
class IMapList {
public:
virtual void Release() = 0;
virtual size_t Count() const = 0;
virtual IMetadataMap* GetMetadata(size_t index) const = 0;
virtual IMap* GetAt(size_t index) const = 0;
};
} } }

49
src/core/sdk/IResource.h Normal file
View File

@ -0,0 +1,49 @@
//////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2007-2017 musikcube team
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// * Neither the name of the author nor the names of other contributors may
// be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////
#pragma once
#include <stddef.h>
#include "constants.h"
namespace musik { namespace core { namespace sdk {
class IResource {
public:
virtual int64_t GetId() = 0;
virtual ResourceType GetResourceType() = 0;
};
} } }

18
src/core/sdk/IRetainedTrack.h
View File

@ -36,17 +36,13 @@
#include "ITrack.h"
namespace musik {
namespace core {
namespace sdk {
namespace musik { namespace core { namespace sdk {
class IRetainedTrack : public ITrack {
public:
virtual void Release() = 0;
virtual void Retain() = 0;
};
class IRetainedTrack : public ITrack {
public:
virtual void Release() = 0;
virtual void Retain() = 0;
};
}
}
}
} } }

4
src/core/sdk/IRetainedTrackWriter.h
View File

@ -34,13 +34,13 @@
#pragma once
#include "ITrackWriter.h"
#include "ITagStore.h"
namespace musik {
namespace core {
namespace sdk {
class IRetainedTrackWriter : public ITrackWriter {
class IRetainedTrackWriter : public ITagStore {
public:
virtual void Release() = 0;
virtual void Retain() = 0;

10
src/core/sdk/ISimpleDataProvider.h
View File

@ -35,8 +35,8 @@
#pragma once
#include "ITrackList.h"
#include "IMetadataValueList.h"
#include "IMetadataMapList.h"
#include "IValueList.h"
#include "IMapList.h"
#include "IRetainedTrack.h"
namespace musik { namespace core { namespace sdk {
@ -59,13 +59,13 @@ namespace musik { namespace core { namespace sdk {
int limit = -1,
int offset = 0) = 0;
virtual IMetadataValueList* QueryCategory(
virtual IValueList* QueryCategory(
const char* type,
const char* filter = "") = 0;
virtual IMetadataMapList* QueryAlbums(const char* filter = "") = 0;
virtual IMapList* QueryAlbums(const char* filter = "") = 0;
virtual IMetadataMapList* QueryAlbums(
virtual IMapList* QueryAlbums(
const char* categoryIdName,
int64_t categoryIdValue,
const char* filter = "") = 0;

6
src/core/sdk/IMetadataReader.h → src/core/sdk/ITagReader.h
View File

@ -34,13 +34,13 @@
#pragma once
#include "ITrackWriter.h"
#include "ITagStore.h"
namespace musik { namespace core { namespace sdk {
class IMetadataReader {
class ITagReader {
public:
virtual bool Read(const char *uri, musik::core::sdk::ITrackWriter *target) = 0;
virtual bool Read(const char *uri, musik::core::sdk::ITagStore *target) = 0;
virtual bool CanRead(const char *extension) = 0;
virtual void Destroy() = 0;
};

2
src/core/sdk/ITrackWriter.h → src/core/sdk/ITagStore.h
View File

@ -36,7 +36,7 @@
namespace musik { namespace core { namespace sdk {
class ITrackWriter {
class ITagStore {
public:
virtual void SetValue(const char* metakey, const char* value) = 0;
virtual void ClearValue(const char* metakey) = 0;

2
src/core/sdk/ITrack.h
View File

@ -41,7 +41,7 @@ namespace musik { namespace core { namespace sdk {
class ITrack {
public:
virtual int64_t GetId() = 0;
virtual int GetValue(const char* key, char* dst, int size) = 0;
virtual int GetString(const char* key, char* dst, int size) = 0;
virtual long long GetInt64(const char* key, long long defaultValue = 0LL) = 0;
virtual int GetInt32(const char* key, unsigned int defaultValue = 0) = 0;
virtual double GetDouble(const char* key, double defaultValue = 0.0f) = 0;

30
src/core/sdk/ITrackList.h
View File

@ -37,24 +37,20 @@
#include <stddef.h>
#include "IRetainedTrack.h"
namespace musik {
namespace core {
namespace sdk {
namespace musik { namespace core { namespace sdk {
class ITrackList {
public:
/* sdk v1 */
virtual void Release() = 0;
virtual size_t Count() const = 0;
virtual IRetainedTrack* GetRetainedTrack(size_t index) const = 0;
virtual int64_t GetId(size_t index) const = 0;
virtual int IndexOf(int64_t id) const = 0;
class ITrackList {
public:
/* sdk v1 */
virtual void Release() = 0;
virtual size_t Count() const = 0;
virtual IRetainedTrack* GetRetainedTrack(size_t index) const = 0;
virtual int64_t GetId(size_t index) const = 0;
virtual int IndexOf(int64_t id) const = 0;
/* sdk v3 */
virtual ITrack* GetTrack(size_t index) const = 0;
};
/* sdk v3 */
virtual ITrack* GetTrack(size_t index) const = 0;
};
}
}
}
} } }

5
src/core/sdk/IMetadataValue.h → src/core/sdk/IValue.h
View File

@ -34,14 +34,13 @@
#pragma once
#include "IResource.h"
#include <stddef.h>
namespace musik { namespace core { namespace sdk {
class IMetadataValue {
class IValue : public IResource {
public:
virtual int64_t GetId() = 0;
virtual const char* GetValue() = 0;
virtual int GetValue(char* dst, size_t size) = 0;
};

6
src/core/sdk/IMetadataValueList.h → src/core/sdk/IValueList.h
View File

@ -35,15 +35,15 @@
#pragma once
#include <stddef.h>
#include "IMetadataValue.h"
#include "IValue.h"
namespace musik { namespace core { namespace sdk {
class IMetadataValueList {
class IValueList {
public:
virtual void Release() = 0;
virtual size_t Count() = 0;
virtual IMetadataValue* GetAt(size_t index) = 0;
virtual IValue* GetAt(size_t index) = 0;
};
} } }

5
src/core/sdk/constants.h
View File

@ -101,6 +101,11 @@ namespace musik {
ScanRollback
};
enum class ResourceType {
Value,
Map
};
namespace category {
static const char* Album = "album";
static const char* Artist = "artist";

10
src/musikcube/app/layout/NowPlayingLayout.cpp
View File

@ -287,22 +287,22 @@ bool NowPlayingLayout::ProcessEditOperation(const std::string& key) {
static std::string formatWithAlbum(TrackPtr track, size_t width) {
std::string trackNum = text::Align(
track->GetValue(constants::Track::TRACK_NUM),
track->GetString(constants::Track::TRACK_NUM),
text::AlignRight,
TRACK_COL_WIDTH);
std::string duration = text::Align(
duration::Duration(track->GetValue(constants::Track::DURATION)),
duration::Duration(track->GetString(constants::Track::DURATION)),
text::AlignRight,
DURATION_COL_WIDTH);
std::string album = text::Align(
track->GetValue(constants::Track::ALBUM),
track->GetString(constants::Track::ALBUM),
text::AlignLeft,
ALBUM_COL_WIDTH);
std::string artist = text::Align(
track->GetValue(constants::Track::ARTIST),
track->GetString(constants::Track::ARTIST),
text::AlignLeft,
ARTIST_COL_WIDTH);
@ -317,7 +317,7 @@ static std::string formatWithAlbum(TrackPtr track, size_t width) {
titleWidth = std::max(0, titleWidth);
std::string title = text::Align(
track->GetValue(constants::Track::TITLE),
track->GetString(constants::Track::TITLE),
text::AlignLeft,
(int) titleWidth);

4
src/musikcube/app/window/CategoryListView.cpp
View File

@ -177,7 +177,7 @@ void CategoryListView::ScrollToPlaying() {
/* by name: slower. also, not currently used, but will be in the near
future when we open up category browsing to other types of metadata */
else {
std::string value = this->playing->GetValue(this->fieldName.c_str());
std::string value = this->playing->GetString(this->fieldName.c_str());
if (value.size()) {
/* binary search would be better, but need to research if sqlite
properly sorts utf8 strings. */
@ -272,7 +272,7 @@ IScrollAdapter::EntryPtr CategoryListView::Adapter::GetEntry(cursespp::Scrollabl
playing = (playingId == parent.metadata->at(index)->id);
}
else {
playing = parent.playing->GetValue(parent.fieldName.c_str()) == value;
playing = parent.playing->GetString(parent.fieldName.c_str()) == value;
}
}

10
src/musikcube/app/window/TrackListView.cpp
View File

@ -343,17 +343,17 @@ size_t TrackListView::Adapter::GetEntryCount() {
static std::string formatWithoutAlbum(TrackPtr track, size_t width) {
std::string trackNum = text::Align(
track->GetValue(constants::Track::TRACK_NUM),
track->GetString(constants::Track::TRACK_NUM),
text::AlignRight,
TRACK_COL_WIDTH);
std::string duration = text::Align(
musik::glue::duration::Duration(track->GetValue(constants::Track::DURATION)),
musik::glue::duration::Duration(track->GetString(constants::Track::DURATION)),
text::AlignRight,
DURATION_COL_WIDTH);
std::string artist = text::Align(
track->GetValue(constants::Track::ARTIST),
track->GetString(constants::Track::ARTIST),
text::AlignLeft,
ARTIST_COL_WIDTH);
@ -367,7 +367,7 @@ static std::string formatWithoutAlbum(TrackPtr track, size_t width) {
titleWidth = std::max(0, titleWidth);
std::string title = text::Align(
track->GetValue(constants::Track::TITLE),
track->GetString(constants::Track::TITLE),
text::AlignLeft,
(int) titleWidth);
@ -386,7 +386,7 @@ IScrollAdapter::EntryPtr TrackListView::Adapter::GetEntry(cursespp::ScrollableWi
TrackPtr track = parent.tracks->Get(trackIndex);
if (track) {
std::string album = track->GetValue(constants::Track::ALBUM);
std::string album = track->GetString(constants::Track::ALBUM);
if (!album.size()) {
album = _TSTR("tracklist_unknown_album");

8
src/musikcube/app/window/TransportWindow.cpp
View File

@ -195,22 +195,22 @@ struct musik::cube::TransportDisplayCache {
this->track = track;
if (this->track) {
title = this->track->GetValue(constants::Track::TITLE);
title = this->track->GetString(constants::Track::TITLE);
title = title.size() ? title : Strings.EMPTY_SONG;
titleCols = u8cols(title);
album = this->track->GetValue(constants::Track::ALBUM);
album = this->track->GetString(constants::Track::ALBUM);
album = album.size() ? album : Strings.EMPTY_ALBUM;
albumCols = u8cols(album);
artist = this->track->GetValue(constants::Track::ARTIST);
artist = this->track->GetString(constants::Track::ARTIST);
artist = artist.size() ? artist : Strings.EMPTY_ARTIST;
artistCols = u8cols(artist);
secondsTotal = (int)transport.GetDuration();
if (secondsTotal <= 0) {
std::string duration =
this->track->GetValue(constants::Track::DURATION);
this->track->GetString(constants::Track::DURATION);
if (duration.size()) {
secondsTotal = boost::lexical_cast<int>(duration);

2
src/plugins/cddadecoder/CddaDataStreamFactory.h
View File

@ -33,7 +33,7 @@
//////////////////////////////////////////////////////////////////////////////
#include <core/sdk/IDataStreamFactory.h>
#include <core/sdk/IMetadataReader.h>
#include <core/sdk/ITagReader.h>
#include <string>
using namespace musik::core::sdk;

26
src/plugins/taglib_plugin/TaglibMetadataReader.cpp
View File

@ -121,7 +121,7 @@ bool TaglibMetadataReader::CanRead(const char *extension){
return false;
}
bool TaglibMetadataReader::Read(const char* uri, musik::core::sdk::ITrackWriter *track) {
bool TaglibMetadataReader::Read(const char* uri, musik::core::sdk::ITagStore *track) {
std::string path(uri);
std::string extension;
@ -155,7 +155,7 @@ bool TaglibMetadataReader::Read(const char* uri, musik::core::sdk::ITrackWriter
return success;
}
bool TaglibMetadataReader::ReadGeneric(const char* uri, musik::core::sdk::ITrackWriter *target) {
bool TaglibMetadataReader::ReadGeneric(const char* uri, musik::core::sdk::ITagStore *target) {
#ifdef WIN32
TagLib::FileRef file(utf8to16(uri).c_str());
#else
@ -236,7 +236,7 @@ void TaglibMetadataReader::ExtractValueForKey(
const TagLib::MP4::ItemMap& map,
const std::string& inputKey,
const std::string& outputKey,
musik::core::sdk::ITrackWriter *target)
musik::core::sdk::ITagStore *target)
{
if (map.contains(inputKey.c_str())) {
TagLib::StringList value = map[inputKey.c_str()].toStringList();
@ -251,7 +251,7 @@ void TaglibMetadataReader::ExtractValueForKey(
const T& map,
const std::string& inputKey,
const std::string& outputKey,
musik::core::sdk::ITrackWriter *target)
musik::core::sdk::ITagStore *target)
{
if (map.contains(inputKey.c_str())) {
TagLib::StringList value = map[inputKey.c_str()];
@ -262,13 +262,13 @@ void TaglibMetadataReader::ExtractValueForKey(
}
template <typename T>
void TaglibMetadataReader::ReadFromMap(const T& map, musik::core::sdk::ITrackWriter *target) {
void TaglibMetadataReader::ReadFromMap(const T& map, musik::core::sdk::ITagStore *target) {
ExtractValueForKey(map, "DISCNUMBER", "disc", target);
ExtractValueForKey(map, "ALBUM ARTIST", "album_artist", target);
ExtractValueForKey(map, "ALBUMARTIST", "album_artist", target);
}
bool TaglibMetadataReader::ReadID3V2(const char* uri, musik::core::sdk::ITrackWriter *track) {
bool TaglibMetadataReader::ReadID3V2(const char* uri, musik::core::sdk::ITagStore *track) {
TagLib::ID3v2::FrameFactory::instance()->setDefaultTextEncoding(TagLib::String::UTF8);
#ifdef WIN32
@ -442,7 +442,7 @@ bool TaglibMetadataReader::ReadID3V2(const char* uri, musik::core::sdk::ITrackWr
void TaglibMetadataReader::SetTagValue(
const char* key,
const TagLib::String tagString,
musik::core::sdk::ITrackWriter *track)
musik::core::sdk::ITagStore *track)
{
std::string value(tagString.to8Bit(true));
track->SetValue(key, value.c_str());
@ -451,7 +451,7 @@ void TaglibMetadataReader::SetTagValue(
void TaglibMetadataReader::SetTagValue(
const char* key,
const char* string,
musik::core::sdk::ITrackWriter *track)
musik::core::sdk::ITagStore *track)
{
std::string temp(string);
track->SetValue(key, temp.c_str());
@ -460,7 +460,7 @@ void TaglibMetadataReader::SetTagValue(
void TaglibMetadataReader::SetTagValue(
const char* key,
const int tagInt,
musik::core::sdk::ITrackWriter *target)
musik::core::sdk::ITagStore *target)
{
std::string temp = boost::str(boost::format("%1%") % tagInt);
target->SetValue(key, temp.c_str());
@ -469,7 +469,7 @@ void TaglibMetadataReader::SetTagValue(
void TaglibMetadataReader::SetTagValues(
const char* key,
const TagLib::ID3v2::FrameList &frame,
musik::core::sdk::ITrackWriter *target)
musik::core::sdk::ITagStore *target)
{
if (!frame.isEmpty()) {
TagLib::ID3v2::FrameList::ConstIterator value = frame.begin();
@ -487,7 +487,7 @@ void TaglibMetadataReader::SetTagValues(
void TaglibMetadataReader::SetSlashSeparatedValues(
const char* key,
TagLib::String tagString,
musik::core::sdk::ITrackWriter *track)
musik::core::sdk::ITagStore *track)
{
if(!tagString.isEmpty()) {
std::string value(tagString.to8Bit(true));
@ -505,7 +505,7 @@ void TaglibMetadataReader::SetSlashSeparatedValues(
void TaglibMetadataReader::SetSlashSeparatedValues(
const char* key,
const TagLib::ID3v2::FrameList &frame,
musik::core::sdk::ITrackWriter *track)
musik::core::sdk::ITagStore *track)
{
if(!frame.isEmpty()) {
TagLib::ID3v2::FrameList::ConstIterator value = frame.begin();
@ -518,7 +518,7 @@ void TaglibMetadataReader::SetSlashSeparatedValues(
void TaglibMetadataReader::SetAudioProperties(
TagLib::AudioProperties *audioProperties,
musik::core::sdk::ITrackWriter *track)
musik::core::sdk::ITagStore *track)
{
/* FIXME: it's overkill to bring boost in just to convert ints to strings */

30
src/plugins/taglib_plugin/TaglibMetadataReader.h
View File

@ -56,69 +56,69 @@
#include <set>
#include <core/sdk/IMetadataReader.h>
#include <core/sdk/ITagReader.h>
class TaglibMetadataReader : public musik::core::sdk::IMetadataReader {
class TaglibMetadataReader : public musik::core::sdk::ITagReader {
public:
TaglibMetadataReader();
~TaglibMetadataReader();
virtual bool Read(const char *uri, musik::core::sdk::ITrackWriter *target);
virtual bool Read(const char *uri, musik::core::sdk::ITagStore *target);
virtual bool CanRead(const char *extension);
virtual void Destroy();
private:
template <typename T> void ReadFromMap(
const T& map, musik::core::sdk::ITrackWriter *target);
const T& map, musik::core::sdk::ITagStore *target);
template <typename T> void ExtractValueForKey(
const T& map,
const std::string& inputKey,
const std::string& outputKey,
musik::core::sdk::ITrackWriter *target);
musik::core::sdk::ITagStore *target);
void ExtractValueForKey(
const TagLib::MP4::ItemMap& map,
const std::string& inputKey,
const std::string& outputKey,
musik::core::sdk::ITrackWriter *target);
musik::core::sdk::ITagStore *target);
void SetTagValue(
const char* key,
const char* string,musik::core::sdk::ITrackWriter *target);
const char* string,musik::core::sdk::ITagStore *target);
void SetTagValue(
const char* key,
const TagLib::String tagString,
musik::core::sdk::ITrackWriter *target);
musik::core::sdk::ITagStore *target);
void SetTagValue(
const char* key,
const int tagInt,musik::core::sdk::ITrackWriter *target);
const int tagInt,musik::core::sdk::ITagStore *target);
void SetTagValues(const char* key,
const TagLib::ID3v2::FrameList &frame,
musik::core::sdk::ITrackWriter *target);
musik::core::sdk::ITagStore *target);
void SetAudioProperties(
TagLib::AudioProperties *audioProperties,
musik::core::sdk::ITrackWriter *target);
musik::core::sdk::ITagStore *target);
void SetSlashSeparatedValues(
const char* key,
const TagLib::ID3v2::FrameList &frame,
musik::core::sdk::ITrackWriter *target);
musik::core::sdk::ITagStore *target);
void SetSlashSeparatedValues(
const char* key,
TagLib::String tagString,
musik::core::sdk::ITrackWriter *target);
musik::core::sdk::ITagStore *target);
bool ReadID3V2(
const char* uri,
musik::core::sdk::ITrackWriter *target);
musik::core::sdk::ITagStore *target);
bool ReadGeneric(
const char* uri,
musik::core::sdk::ITrackWriter *target);
musik::core::sdk::ITagStore *target);
};

6
src/plugins/taglib_plugin/taglib_plugin.cpp
View File

@ -52,8 +52,8 @@
class TaglibPlugin : public musik::core::sdk::IPlugin {
public:
virtual void Destroy() { delete this; }
virtual const char* Name() { return "Taglib 1.11 IMetadataReader"; }
virtual const char* Version() { return "0.5.0"; }
virtual const char* Name() { return "Taglib 1.11 ITagReader"; }
virtual const char* Version() { return "0.6.0"; }
virtual const char* Author() { return "Daniel Önnerby, clangen"; }
virtual const char* Guid() { return "c77ea7a4-5d57-4f17-8521-aba8eeadeda7"; }
virtual bool Configurable() { return false; }
@ -62,7 +62,7 @@ class TaglibPlugin : public musik::core::sdk::IPlugin {
virtual int SdkVersion() { return musik::core::sdk::SdkVersion; }
};
extern "C" DLLEXPORT musik::core::sdk::IMetadataReader* GetMetadataReader() {
extern "C" DLLEXPORT musik::core::sdk::ITagReader* GetTagReader() {
return new TaglibMetadataReader();
}

9
src/plugins/websocket_remote/Util.h
View File

@ -37,8 +37,8 @@
#include <string>
#include <boost/bimap.hpp>
#include <core/sdk/constants.h>
#include <core/sdk/IPreferences.h>
#include <core/sdk/IValue.h>
#ifdef WIN32
#include <Windows.h>
@ -68,7 +68,12 @@ static std::string GetPreferenceString(
template <typename MetadataT>
static std::string GetMetadataString(MetadataT* metadata, const std::string& key) {
metadata->GetValue(key.c_str(), threadLocalBuffer, sizeof(threadLocalBuffer));
metadata->GetString(key.c_str(), threadLocalBuffer, sizeof(threadLocalBuffer));
return std::string(threadLocalBuffer);
}
static std::string GetValueString(musik::core::sdk::IValue* value) {
value->GetValue(threadLocalBuffer, sizeof(threadLocalBuffer));
return std::string(threadLocalBuffer);
}

14
src/plugins/websocket_remote/WebSocketServer.cpp
View File

@ -604,17 +604,17 @@ void WebSocketServer::RespondWithQueryAlbums(connection_hdl connection, json& re
std::string category = options.value(key::category, "");
uint64_t categoryId = options.value(key::category_id, -1);
IMetadataMapList* albumList = context.dataProvider
IMapList* albumList = context.dataProvider
->QueryAlbums(category.c_str(), categoryId, filter.c_str());
json result = json::array();
IMetadataMap* album;
IMap* album;
for (size_t i = 0; i < albumList->Count(); i++) {
album = albumList->GetMetadata(i);
album = albumList->GetAt(i);
result.push_back({
{ key::title, album->GetDescription() },
{ key::title, GetValueString(album) },
{ key::id, album->GetId() },
{ key::thumbnail_id, 0 }, /* note: thumbnails aren't supported at the album level yet */
{ key::album_artist_id, album->GetInt64(key::album_artist_id.c_str()) },
@ -703,19 +703,19 @@ void WebSocketServer::RespondWithQueryCategory(connection_hdl connection, json&
std::string filter = request[message::options].value(key::filter, "");
if (category.size()) {
IMetadataValueList* result = context.dataProvider
IValueList* result = context.dataProvider
->QueryCategory(category.c_str(), filter.c_str());
if (result != nullptr) {
json list = json::array();
IMetadataValue* current;
IValue* current;
for (size_t i = 0; i < result->Count(); i++) {
current = result->GetAt(i);
list[i] = {
{ key::id, current->GetId() },
{ key::value, current->GetValue() }
{ key::value, GetValueString(current) }
};
}