mirror/taglib
1
0
Fork 0
mirror of https://github.com/taglib/taglib.git synced 2025-07-26 00:44:31 -04:00
Code Issues Packages Projects Releases Wiki Activity

Hide string handler implementations from public headers.

Browse Source
This commit is contained in:
Tsuda Kageyu
2015-11-19 14:08:40 +09:00
parent 5da35f5a51
commit dbe3a03b62
6 changed files with 87 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
taglib/mpeg/id3v1/id3v1tag.cpp
View File

@ -32,6 +32,28 @@
using namespace TagLib;
using namespace ID3v1;
namespace
{
class DefaultStringHandler : public TagLib::StringHandler
{
virtual String parse(const ByteVector &data) const
{
return String(data, String::Latin1).stripWhiteSpace();
}
virtual ByteVector render(const String &s) const
{
if(s.isLatin1())
return s.data(String::Latin1);
else
return ByteVector();
}
};
const DefaultStringHandler defaultStringHandler;
const TagLib::StringHandler *stringHandler = &defaultStringHandler;
}
class ID3v1::Tag::TagPrivate
{
public:
@ -47,38 +69,8 @@ public:
String comment;
uchar track;
uchar genre;
static const TagLib::StringHandler *stringHandler;
};
namespace
{
const ID3v1::StringHandler defaultStringHandler;
}
const TagLib::StringHandler *ID3v1::Tag::TagPrivate::stringHandler = &defaultStringHandler;
////////////////////////////////////////////////////////////////////////////////
// StringHandler implementation
////////////////////////////////////////////////////////////////////////////////
ID3v1::StringHandler::StringHandler()
{
}
String ID3v1::StringHandler::parse(const ByteVector &data) const
{
return String(data, String::Latin1).stripWhiteSpace();
}
ByteVector ID3v1::StringHandler::render(const String &s) const
{
if(s.isLatin1())
return s.data(String::Latin1);
else
return ByteVector();
}
////////////////////////////////////////////////////////////////////////////////
// public methods
////////////////////////////////////////////////////////////////////////////////
@ -107,11 +99,11 @@ ByteVector ID3v1::Tag::render() const
ByteVector data;
data.append(fileIdentifier());
data.append(TagPrivate::stringHandler->render(d->title).resize(30));
data.append(TagPrivate::stringHandler->render(d->artist).resize(30));
data.append(TagPrivate::stringHandler->render(d->album).resize(30));
data.append(TagPrivate::stringHandler->render(d->year).resize(4));
data.append(TagPrivate::stringHandler->render(d->comment).resize(28));
data.append(stringHandler->render(d->title).resize(30));
data.append(stringHandler->render(d->artist).resize(30));
data.append(stringHandler->render(d->album).resize(30));
data.append(stringHandler->render(d->year).resize(4));
data.append(stringHandler->render(d->comment).resize(28));
data.append(char(0));
data.append(char(d->track));
data.append(char(d->genre));
@ -207,9 +199,9 @@ void ID3v1::Tag::setGenreNumber(TagLib::uint i)
void ID3v1::Tag::setStringHandler(const TagLib::StringHandler *handler)
{
if(handler)
TagPrivate::stringHandler = handler;
stringHandler = handler;
else
TagPrivate::stringHandler = &defaultStringHandler;
stringHandler = &defaultStringHandler;
}
////////////////////////////////////////////////////////////////////////////////
@ -235,16 +227,16 @@ void ID3v1::Tag::parse(const ByteVector &data)
{
int offset = 3;
d->title = TagPrivate::stringHandler->parse(data.mid(offset, 30));
d->title = stringHandler->parse(data.mid(offset, 30));
offset += 30;
d->artist = TagPrivate::stringHandler->parse(data.mid(offset, 30));
d->artist = stringHandler->parse(data.mid(offset, 30));
offset += 30;
d->album = TagPrivate::stringHandler->parse(data.mid(offset, 30));
d->album = stringHandler->parse(data.mid(offset, 30));
offset += 30;
d->year = TagPrivate::stringHandler->parse(data.mid(offset, 4));
d->year = stringHandler->parse(data.mid(offset, 4));
offset += 4;
// Check for ID3v1.1 -- Note that ID3v1 *does not* support "track zero" -- this
@ -255,7 +247,7 @@ void ID3v1::Tag::parse(const ByteVector &data)
if(data[offset + 28] == 0 && data[offset + 29] != 0) {
// ID3v1.1 detected
d->comment = TagPrivate::stringHandler->parse(data.mid(offset, 28));
d->comment = stringHandler->parse(data.mid(offset, 28));
d->track = uchar(data[offset + 29]);
}
else

44
taglib/mpeg/id3v1/id3v1tag.h
View File

@ -39,48 +39,6 @@ namespace TagLib {
namespace ID3v1 {
//! A abstraction for the string to data encoding in ID3v1 tags.
/*!
* ID3v1 should in theory always contain ISO-8859-1 (Latin1) data. In
* practice it does not. TagLib by default only supports ISO-8859-1 data
* in ID3v1 tags.
*
* However by subclassing TagLib::StringHandler class and reimplementing
* parse() and render() and setting your reimplementation as the default
* with ID3v1::Tag::setStringHandler() you can define how you would like
* these transformations to be done.
*
* \warning It is advisable <b>not</b> to write non-ISO-8859-1 data to ID3v1
* tags. Please consider disabling the writing of ID3v1 tags in the case
* that the data is not ISO-8859-1.
*
* \see ID3v1::Tag::setStringHandler()
*/
class TAGLIB_EXPORT StringHandler : public TagLib::StringHandler
{
public:
StringHandler();
/*!
* Decode a string from \a data. The default implementation assumes that
* \a data is an ISO-8859-1 (Latin1) character array.
*/
virtual String parse(const ByteVector &data) const;
/*!
* Encode a ByteVector with the data from \a s. The default implementation
* assumes that \a s is an ISO-8859-1 (Latin1) string. If the string is
* does not conform to ISO-8859-1, no value is written.
*
* \warning It is recommended that you <b>not</b> override this method, but
* instead do not write an ID3v1 tag in the case that the data is not
* ISO-8859-1.
*/
virtual ByteVector render(const String &s) const;
};
//! The main class in the ID3v1 implementation
/*!
@ -173,8 +131,6 @@ namespace TagLib {
*
* \note The caller is responsible for deleting the previous handler
* as needed after it is released.
*
* \see StringHandler
*/
static void setStringHandler(const TagLib::StringHandler *handler);

63
taglib/mpeg/id3v2/id3v2tag.cpp
View File

@ -51,6 +51,29 @@
using namespace TagLib;
using namespace ID3v2;
namespace
{
class DefaultStringHandler : public TagLib::StringHandler
{
virtual String parse(const ByteVector &data) const
{
return String(data, String::Latin1);
}
virtual ByteVector render(const String &s) const
{
// Not implemented on purpose. This function is never used.
return ByteVector();
}
};
const DefaultStringHandler defaultStringHandler;
const TagLib::StringHandler *stringHandler = &defaultStringHandler;
const offset_t MinPaddingSize = 1024;
const offset_t MaxPaddingSize = 1024 * 1024;
}
class ID3v2::Tag::TagPrivate
{
public:
@ -79,41 +102,8 @@ public:
FrameListMap frameListMap;
FrameList frameList;
static const TagLib::StringHandler *stringHandler;
};
namespace
{
const ID3v2::Latin1StringHandler defaultStringHandler;
}
const TagLib::StringHandler *ID3v2::Tag::TagPrivate::stringHandler = &defaultStringHandler;
namespace
{
const offset_t MinPaddingSize = 1024;
const offset_t MaxPaddingSize = 1024 * 1024;
}
////////////////////////////////////////////////////////////////////////////////
// Latin1StringHandler implementation
////////////////////////////////////////////////////////////////////////////////
ID3v2::Latin1StringHandler::Latin1StringHandler()
{
}
String ID3v2::Latin1StringHandler::parse(const ByteVector &data) const
{
return String(data, String::Latin1);
}
ByteVector ID3v2::Latin1StringHandler::render(const String &) const
{
return ByteVector();
}
////////////////////////////////////////////////////////////////////////////////
// public members
////////////////////////////////////////////////////////////////////////////////
@ -141,7 +131,6 @@ ID3v2::Tag::~Tag()
delete d;
}
String ID3v2::Tag::title() const
{
if(!d->frameListMap["TIT2"].isEmpty())
@ -654,15 +643,15 @@ ByteVector ID3v2::Tag::render(int version) const
TagLib::StringHandler const *ID3v2::Tag::latin1StringHandler()
{
return TagPrivate::stringHandler;
return stringHandler;
}
void ID3v2::Tag::setLatin1StringHandler(const TagLib::StringHandler *handler)
{
if(handler)
TagPrivate::stringHandler = handler;
stringHandler = handler;
else
TagPrivate::stringHandler = &defaultStringHandler;
stringHandler = &defaultStringHandler;
}
////////////////////////////////////////////////////////////////////////////////

43
taglib/mpeg/id3v2/id3v2tag.h
View File

@ -58,42 +58,6 @@ namespace TagLib {
typedef List<Frame *> FrameList;
typedef Map<ByteVector, FrameList> FrameListMap;
//! An abstraction for the ISO-8859-1 string to data encoding in ID3v2 tags.
/*!
* ID3v2 tag can store strings in ISO-8859-1 (Latin1), and TagLib only
* supports genuine ISO-8859-1 by default. However, in practice, non
* ISO-8859-1 encodings are often used instead of ISO-8859-1, such as
* Windows-1252 for western languages, Shift_JIS for Japanese and so on.
*
* Here is an option to read such tags by subclassing this class,
* reimplementing parse() and setting your reimplementation as the default
* with ID3v2::Tag::setStringHandler().
*
* \note Writing non-ISO-8859-1 tags is not implemented intentionally.
* Use UTF-16 or UTF-8 instead.
*
* \see ID3v2::Tag::setStringHandler()
*/
class TAGLIB_EXPORT Latin1StringHandler : public TagLib::StringHandler
{
public:
Latin1StringHandler();
/*!
* Decode a string from \a data. The default implementation assumes that
* \a data is an ISO-8859-1 (Latin1) character array.
*/
virtual String parse(const ByteVector &data) const;
/*!
* Encode a ByteVector with the data from \a s.
*
* \note Not implemented intentionally. Always returns empty \s ByteVector.
*/
virtual ByteVector render(const String &s) const;
};
//! The main class in the ID3v2 implementation
/*!
@ -364,8 +328,6 @@ namespace TagLib {
/*!
* Gets the current string handler that decides how the "Latin-1" data
* will be converted to and from binary data.
*
* \see Latin1StringHandler
*/
static TagLib::StringHandler const *latin1StringHandler();
@ -378,7 +340,10 @@ namespace TagLib {
* \note The caller is responsible for deleting the previous handler
* as needed after it is released.
*
* \see Latin1StringHandler
* \note User defined string handers are not used for rendering tags.
* TagLib doesn't support writing non-standard tags.
*
* \see latin1StringHandler
*/
static void setLatin1StringHandler(const TagLib::StringHandler *handler);

57
taglib/riff/wav/infotag.cpp
View File

@ -32,42 +32,31 @@
using namespace TagLib;
using namespace RIFF::Info;
namespace
{
class DefaultStringHandler : public TagLib::StringHandler
{
virtual String parse(const ByteVector &data) const
{
return String(data, String::UTF8);
}
virtual ByteVector render(const String &s) const
{
return s.data(String::UTF8);
}
};
const DefaultStringHandler defaultStringHandler;
const TagLib::StringHandler *stringHandler = &defaultStringHandler;
}
class RIFF::Info::Tag::TagPrivate
{
public:
TagPrivate()
{}
FieldMap fieldMap;
static const TagLib::StringHandler *stringHandler;
};
namespace
{
const RIFF::Info::StringHandler defaultStringHandler;
}
const TagLib::StringHandler *RIFF::Info::Tag::TagPrivate::stringHandler = &defaultStringHandler;
////////////////////////////////////////////////////////////////////////////////
// StringHandler implementation
////////////////////////////////////////////////////////////////////////////////
RIFF::Info::StringHandler::StringHandler()
{
}
String RIFF::Info::StringHandler::parse(const ByteVector &data) const
{
return String(data, String::UTF8);
}
ByteVector RIFF::Info::StringHandler::render(const String &s) const
{
return s.data(String::UTF8);
}
////////////////////////////////////////////////////////////////////////////////
// public members
////////////////////////////////////////////////////////////////////////////////
@ -208,7 +197,7 @@ ByteVector RIFF::Info::Tag::render() const
FieldMap::ConstIterator it = d->fieldMap.begin();
for(; it != d->fieldMap.end(); ++it) {
ByteVector text = TagPrivate::stringHandler->render(it->second);
ByteVector text = stringHandler->render(it->second);
if(text.isEmpty())
continue;
@ -230,9 +219,9 @@ ByteVector RIFF::Info::Tag::render() const
void RIFF::Info::Tag::setStringHandler(const TagLib::StringHandler *handler)
{
if(handler)
TagPrivate::stringHandler = handler;
stringHandler = handler;
else
TagPrivate::stringHandler = &defaultStringHandler;
stringHandler = &defaultStringHandler;
}
////////////////////////////////////////////////////////////////////////////////
@ -249,7 +238,7 @@ void RIFF::Info::Tag::parse(const ByteVector &data)
const ByteVector id = data.mid(p, 4);
if(RIFF::File::isValidChunkName(id)) {
const String text = TagPrivate::stringHandler->parse(data.mid(p + 8, size));
const String text = stringHandler->parse(data.mid(p + 8, size));
d->fieldMap[id] = text;
}

34
taglib/riff/wav/infotag.h
View File

@ -45,38 +45,6 @@ namespace TagLib {
typedef Map<ByteVector, String> FieldMap;
//! A abstraction for the string to data encoding in Info tags.
/*!
* RIFF INFO tag has no clear definitions about character encodings.
* In practice, local encoding of each system is largely used and UTF-8 is
* popular too.
*
* Here is an option to read and write tags in your preferred encoding
* by subclassing this class, reimplementing parse() and render() and setting
* your reimplementation as the default with Info::Tag::setStringHandler().
*
* \see ID3v1::Tag::setStringHandler()
*/
class TAGLIB_EXPORT StringHandler : public TagLib::StringHandler
{
public:
StringHandler();
/*!
* Decode a string from \a data. The default implementation assumes that
* \a data is an UTF-8 character array.
*/
virtual String parse(const ByteVector &data) const;
/*!
* Encode a ByteVector with the data from \a s. The default implementation
* assumes that \a s is an UTF-8 string.
*/
virtual ByteVector render(const String &s) const;
};
//! The main class in the RIFF INFO tag implementation
/*!
@ -169,8 +137,6 @@ namespace TagLib {
*
* \note The caller is responsible for deleting the previous handler
* as needed after it is released.
*
* \see StringHandler
*/
static void setStringHandler(const TagLib::StringHandler *handler);