oysteikt
/
mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

util/StringView: new utility class

This commit is contained in:
Max Kellermann 2015-09-30 22:03:01 +02:00
parent ffbb5c48ed
commit 356c829b76
18 changed files with 208 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.am
View File

@ -401,6 +401,7 @@ libutil_a_SOURCES = \
src/util/CharUtil.hxx \
src/util/NumberParser.hxx \
src/util/StringPointer.hxx \
src/util/StringView.hxx \
src/util/AllocatedString.cxx src/util/AllocatedString.hxx \
src/util/StringUtil.cxx src/util/StringUtil.hxx \
src/util/WStringUtil.cxx src/util/WStringUtil.hxx \

3
src/IcyMetaDataParser.cxx
View File

@ -22,6 +22,7 @@
#include "tag/Tag.hxx"
#include "tag/TagBuilder.hxx"
#include "util/Domain.hxx"
#include "util/StringView.hxx"
#include "Log.hxx"
#include <assert.h>
@ -76,7 +77,7 @@ icy_add_item(TagBuilder &tag, TagType type, const char *value)
}
if (length > 0)
tag.AddItem(type, value, length);
tag.AddItem(type, {value, length});
}
static void

19
src/db/plugins/upnp/Directory.cxx
View File

@ -25,6 +25,7 @@
#include "tag/TagBuilder.hxx"
#include "tag/TagTable.hxx"
#include "util/NumberParser.hxx"
#include "util/StringView.hxx"
#include <algorithm>
#include <string>
@ -36,23 +37,13 @@ UPnPDirContent::~UPnPDirContent()
/* this destructor exists here just so it won't get inlined */
}
gcc_pure gcc_nonnull_all
static bool
CompareStringLiteral(const char *literal, const char *value, size_t length)
{
return length == strlen(literal) &&
memcmp(literal, value, length) == 0;
}
gcc_pure
static UPnPDirObject::ItemClass
ParseItemClass(const char *name, size_t length)
ParseItemClass(StringView name)
{
if (CompareStringLiteral("object.item.audioItem.musicTrack",
name, length))
if (name.EqualsLiteral("object.item.audioItem.musicTrack"))
return UPnPDirObject::ItemClass::MUSIC;
else if (CompareStringLiteral("object.item.playlistItem",
name, length))
else if (name.EqualsLiteral("object.item.playlistItem"))
return UPnPDirObject::ItemClass::PLAYLIST;
else
return UPnPDirObject::ItemClass::UNKNOWN;
@ -239,7 +230,7 @@ protected:
break;
case CLASS:
object.item_class = ParseItemClass(s, len);
object.item_class = ParseItemClass(StringView(s, len));
break;
}
}

3
src/decoder/plugins/Mpg123DecoderPlugin.cxx
View File

@ -28,6 +28,7 @@
#include "fs/Path.hxx"
#include "util/Error.hxx"
#include "util/Domain.hxx"
#include "util/StringView.hxx"
#include "Log.hxx"
#include <mpg123.h>
@ -111,7 +112,7 @@ AddTagItem(TagBuilder &tag, TagType type, const mpg123_string &s)
assert(s.size >= s.fill);
assert(s.fill > 0);
tag.AddItem(type, s.p, s.fill - 1);
tag.AddItem(type, {s.p, s.fill - 1});
}
static void

4
src/playlist/plugins/AsxPlaylistPlugin.cxx
View File

@ -24,6 +24,7 @@
#include "tag/TagBuilder.hxx"
#include "util/ASCII.hxx"
#include "util/Error.hxx"
#include "util/StringView.hxx"
#include "lib/expat/ExpatParser.hxx"
#include "Log.hxx"
@ -130,7 +131,8 @@ asx_char_data(void *user_data, const XML_Char *s, int len)
case AsxParser::ENTRY:
if (parser->tag_type != TAG_NUM_OF_ITEM_TYPES)
parser->tag_builder.AddItem(parser->tag_type, s, len);
parser->tag_builder.AddItem(parser->tag_type,
StringView(s, len));
break;
}

4
src/playlist/plugins/RssPlaylistPlugin.cxx
View File

@ -24,6 +24,7 @@
#include "tag/TagBuilder.hxx"
#include "util/ASCII.hxx"
#include "util/Error.hxx"
#include "util/StringView.hxx"
#include "lib/expat/ExpatParser.hxx"
#include "Log.hxx"
@ -128,7 +129,8 @@ rss_char_data(void *user_data, const XML_Char *s, int len)
case RssParser::ITEM:
if (parser->tag_type != TAG_NUM_OF_ITEM_TYPES)
parser->tag_builder.AddItem(parser->tag_type, s, len);
parser->tag_builder.AddItem(parser->tag_type,
StringView(s, len));
break;
}

4
src/playlist/plugins/XspfPlaylistPlugin.cxx
View File

@ -25,6 +25,7 @@
#include "input/InputStream.hxx"
#include "tag/TagBuilder.hxx"
#include "util/Error.hxx"
#include "util/StringView.hxx"
#include "lib/expat/ExpatParser.hxx"
#include "Log.hxx"
@ -170,7 +171,8 @@ xspf_char_data(void *user_data, const XML_Char *s, int len)
case XspfParser::TRACK:
if (!parser->location.empty() &&
parser->tag_type != TAG_NUM_OF_ITEM_TYPES)
parser->tag_builder.AddItem(parser->tag_type, s, len);
parser->tag_builder.AddItem(parser->tag_type,
StringView(s, len));
break;

3
src/tag/ApeLoader.cxx
View File

@ -21,6 +21,7 @@
#include "ApeLoader.hxx"
#include "system/ByteOrder.hxx"
#include "fs/FileSystem.hxx"
#include "util/StringView.hxx"
#include <stdint.h>
#include <assert.h>
@ -89,7 +90,7 @@ ape_scan_internal(FILE *fp, ApeTagCallback callback)
if (remaining < size)
break;
if (!callback(flags, key, p, size))
if (!callback(flags, key, {p, size}))
break;
p += size;

4
src/tag/ApeLoader.hxx
View File

@ -26,11 +26,11 @@
#include <stddef.h>
struct StringView;
class Path;
typedef std::function<bool(unsigned long flags, const char *key,
const char *value,
size_t value_length)> ApeTagCallback;
StringView value)> ApeTagCallback;
/**
* Scans the APE tag values from a file.

16
src/tag/ApeReplayGain.cxx
View File

@ -21,15 +21,16 @@
#include "ApeReplayGain.hxx"
#include "ApeLoader.hxx"
#include "ReplayGain.hxx"
#include "util/ASCII.hxx"
#include "fs/Path.hxx"
#include "util/ASCII.hxx"
#include "util/StringView.hxx"
#include <string.h>
#include <stdlib.h>
static bool
replay_gain_ape_callback(unsigned long flags, const char *key,
const char *_value, size_t value_length,
StringView _value,
ReplayGainInfo &info)
{
/* we only care about utf-8 text tags */
@ -37,11 +38,11 @@ replay_gain_ape_callback(unsigned long flags, const char *key,
return false;
char value[16];
if (value_length >= sizeof(value))
if (_value.size >= sizeof(value))
return false;
memcpy(value, _value, value_length);
value[value_length] = 0;
memcpy(value, _value.data, _value.size);
value[_value.size] = 0;
return ParseReplayGainTag(info, key, value);
}
@ -53,10 +54,9 @@ replay_gain_ape_read(Path path_fs, ReplayGainInfo &info)
auto callback = [&info, &found]
(unsigned long flags, const char *key,
const char *value,
size_t value_length) {
StringView value) {
found |= replay_gain_ape_callback(flags, key,
value, value_length,
value,
info);
return true;
};

16
src/tag/ApeTag.cxx
View File

@ -24,6 +24,7 @@
#include "TagTable.hxx"
#include "TagHandler.hxx"
#include "fs/Path.hxx"
#include "util/StringView.hxx"
#include <string>
@ -75,17 +76,18 @@ ForEachValue(const char *value, const char *end, C &&callback)
*/
static bool
tag_ape_import_item(unsigned long flags,
const char *key, const char *value, size_t value_length,
const char *key, StringView value,
const struct tag_handler *handler, void *handler_ctx)
{
/* we only care about utf-8 text tags */
if ((flags & (0x3 << 1)) != 0)
return false;
const char *const end = value + value_length;
const auto begin = value.begin();
const auto end = value.end();
if (handler->pair != nullptr)
ForEachValue(value, end, [handler, handler_ctx,
ForEachValue(begin, end, [handler, handler_ctx,
key](const char *_value) {
handler->pair(key, _value, handler_ctx);
});
@ -94,8 +96,8 @@ tag_ape_import_item(unsigned long flags,
if (type == TAG_NUM_OF_ITEM_TYPES)
return false;
ForEachValue(value, end, [handler, handler_ctx,
type](const char *_value) {
ForEachValue(begin, end, [handler, handler_ctx,
type](const char *_value) {
tag_handler_invoke_tag(handler, handler_ctx,
type, _value);
});
@ -111,10 +113,8 @@ tag_ape_scan2(Path path_fs,
auto callback = [handler, handler_ctx, &recognized]
(unsigned long flags, const char *key,
const char *value,
size_t value_length) {
StringView value) {
recognized |= tag_ape_import_item(flags, key, value,
value_length,
handler, handler_ctx);
return true;
};

34
src/tag/TagBuilder.cxx
View File

@ -24,6 +24,7 @@
#include "TagString.hxx"
#include "Tag.hxx"
#include "util/WritableBuffer.hxx"
#include "util/StringView.hxx"
#include <array>
@ -189,22 +190,16 @@ TagBuilder::Complement(const Tag &other)
}
inline void
TagBuilder::AddItemInternal(TagType type, const char *value, size_t length)
TagBuilder::AddItemInternal(TagType type, StringView value)
{
#if !CLANG_CHECK_VERSION(3,6)
/* disabled on clang due to -Wtautological-pointer-compare */
assert(value != nullptr);
#endif
assert(length > 0);
assert(!value.IsEmpty());
auto f = FixTagString(value, length);
if (!f.IsNull()) {
value = f.data;
length = f.size;
}
auto f = FixTagString(value);
if (!f.IsNull())
value = { f.data, f.size };
tag_pool_lock.lock();
auto i = tag_pool_get_item(type, value, length);
auto i = tag_pool_get_item(type, value);
tag_pool_lock.unlock();
free(f.data);
@ -213,17 +208,12 @@ TagBuilder::AddItemInternal(TagType type, const char *value, size_t length)
}
void
TagBuilder::AddItem(TagType type, const char *value, size_t length)
TagBuilder::AddItem(TagType type, StringView value)
{
#if !CLANG_CHECK_VERSION(3,6)
/* disabled on clang due to -Wtautological-pointer-compare */
assert(value != nullptr);
#endif
if (length == 0 || !IsTagEnabled(type))
if (value.IsEmpty() || !IsTagEnabled(type))
return;
AddItemInternal(type, value, length);
AddItemInternal(type, value);
}
void
@ -234,14 +224,14 @@ TagBuilder::AddItem(TagType type, const char *value)
assert(value != nullptr);
#endif
AddItem(type, value, strlen(value));
AddItem(type, StringView(value));
}
void
TagBuilder::AddEmptyItem(TagType type)
{
tag_pool_lock.lock();
auto i = tag_pool_get_item(type, "", 0);
auto i = tag_pool_get_item(type, StringView::Empty());
tag_pool_lock.unlock();
items.push_back(i);

5
src/tag/TagBuilder.hxx
View File

@ -28,6 +28,7 @@
#include <stddef.h>
struct StringView;
struct TagItem;
struct Tag;
@ -141,7 +142,7 @@ public:
* @param length the length of #value
*/
gcc_nonnull_all
void AddItem(TagType type, const char *value, size_t length);
void AddItem(TagType type, StringView value);
/**
* Appends a new tag item.
@ -171,7 +172,7 @@ public:
private:
gcc_nonnull_all
void AddItemInternal(TagType type, const char *value, size_t length);
void AddItemInternal(TagType type, StringView value);
};
#endif

42
src/tag/TagPool.cxx
View File

@ -22,6 +22,7 @@
#include "TagItem.hxx"
#include "util/Cast.hxx"
#include "util/VarSize.hxx"
#include "util/StringView.hxx"
#include <assert.h>
#include <string.h>
@ -37,39 +38,37 @@ struct TagPoolSlot {
TagItem item;
TagPoolSlot(TagPoolSlot *_next, TagType type,
const char *value, size_t length)
StringView value)
:next(_next), ref(1) {
item.type = type;
memcpy(item.value, value, length);
item.value[length] = 0;
memcpy(item.value, value.data, value.size);
item.value[value.size] = 0;
}
static TagPoolSlot *Create(TagPoolSlot *_next, TagType type,
const char *value, size_t length);
StringView value);
} gcc_packed;
TagPoolSlot *
TagPoolSlot::Create(TagPoolSlot *_next, TagType type,
const char *value, size_t length)
StringView value)
{
TagPoolSlot *dummy;
return NewVarSize<TagPoolSlot>(sizeof(dummy->item.value),
length + 1,
value.size + 1,
_next, type,
value, length);
value);
}
static TagPoolSlot *slots[NUM_SLOTS];
static inline unsigned
calc_hash_n(TagType type, const char *p, size_t length)
calc_hash(TagType type, StringView p)
{
unsigned hash = 5381;
assert(p != nullptr);
while (length-- > 0)
hash = (hash << 5) + hash + *p++;
for (auto ch : p)
hash = (hash << 5) + hash + ch;
return hash ^ type;
}
@ -97,9 +96,9 @@ tag_item_to_slot(TagItem *item)
}
static inline TagPoolSlot **
tag_value_slot_p(TagType type, const char *value, size_t length)
tag_value_slot_p(TagType type, StringView value)
{
return &slots[calc_hash_n(type, value, length) % NUM_SLOTS];
return &slots[calc_hash(type, value) % NUM_SLOTS];
}
static inline TagPoolSlot **
@ -109,13 +108,12 @@ tag_value_slot_p(TagType type, const char *value)
}
TagItem *
tag_pool_get_item(TagType type, const char *value, size_t length)
tag_pool_get_item(TagType type, StringView value)
{
auto slot_p = tag_value_slot_p(type, value, length);
auto slot_p = tag_value_slot_p(type, value);
for (auto slot = *slot_p; slot != nullptr; slot = slot->next) {
if (slot->item.type == type &&
length == strlen(slot->item.value) &&
memcmp(value, slot->item.value, length) == 0 &&
value.Equals(slot->item.value) &&
slot->ref < 0xff) {
assert(slot->ref > 0);
++slot->ref;
@ -123,7 +121,7 @@ tag_pool_get_item(TagType type, const char *value, size_t length)
}
}
auto slot = TagPoolSlot::Create(*slot_p, type, value, length);
auto slot = TagPoolSlot::Create(*slot_p, type, value);
*slot_p = slot;
return &slot->item;
}
@ -141,11 +139,9 @@ tag_pool_dup_item(TagItem *item)
} else {
/* the reference counter overflows above 0xff;
duplicate the item, and start with 1 */
size_t length = strlen(item->value);
auto slot_p = tag_value_slot_p(item->type,
item->value, length);
auto slot_p = tag_value_slot_p(item->type, item->value);
slot = TagPoolSlot::Create(*slot_p, item->type,
item->value, strlen(item->value));
item->value);
*slot_p = slot;
return &slot->item;
}

3
src/tag/TagPool.hxx
View File

@ -26,9 +26,10 @@
extern Mutex tag_pool_lock;
struct TagItem;
struct StringView;
TagItem *
tag_pool_get_item(TagType type, const char *value, size_t length);
tag_pool_get_item(TagType type, StringView value);
TagItem *
tag_pool_dup_item(TagItem *item);

47
src/tag/TagString.cxx
View File

@ -21,6 +21,7 @@
#include "TagString.hxx"
#include "util/Alloc.hxx"
#include "util/WritableBuffer.hxx"
#include "util/StringView.hxx"
#include "util/UTF8.hxx"
#include <assert.h>
@ -54,14 +55,14 @@ FindInvalidUTF8(const char *p, const char *const end)
* Replace invalid sequences with the question mark.
*/
static WritableBuffer<char>
patch_utf8(const char *src, size_t length, const char *_invalid)
patch_utf8(StringView src, const char *_invalid)
{
/* duplicate the string, and replace invalid bytes in that
buffer */
char *dest = (char *)xmemdup(src, length);
char *const end = dest + length;
char *dest = (char *)xmemdup(src.data, src.size);
char *const end = dest + src.size;
char *invalid = dest + (_invalid - src);
char *invalid = dest + (_invalid - src.data);
do {
*invalid = '?';
@ -69,19 +70,19 @@ patch_utf8(const char *src, size_t length, const char *_invalid)
invalid = const_cast<char *>(__invalid);
} while (invalid != nullptr);
return { dest, length };
return { dest, src.size };
}
static WritableBuffer<char>
fix_utf8(const char *str, size_t length)
fix_utf8(StringView p)
{
/* check if the string is already valid UTF-8 */
const char *invalid = FindInvalidUTF8(str, str + length);
const char *invalid = FindInvalidUTF8(p.begin(), p.end());
if (invalid == nullptr)
return nullptr;
/* no, broken - patch invalid sequences */
return patch_utf8(str, length, invalid);
return patch_utf8(p, invalid);
}
static bool
@ -91,11 +92,11 @@ char_is_non_printable(unsigned char ch)
}
static const char *
find_non_printable(const char *p, size_t length)
find_non_printable(StringView p)
{
for (size_t i = 0; i < length; ++i)
if (char_is_non_printable(p[i]))
return p + i;
for (const char &ch : p)
if (char_is_non_printable(ch))
return &ch;
return nullptr;
}
@ -105,31 +106,29 @@ find_non_printable(const char *p, size_t length)
* Returns nullptr if nothing needs to be cleared.
*/
static WritableBuffer<char>
clear_non_printable(const char *p, size_t length)
clear_non_printable(StringView src)
{
const char *first = find_non_printable(p, length);
const char *first = find_non_printable(src);
if (first == nullptr)
return nullptr;
char *dest = (char *)xmemdup(p, length);
char *dest = (char *)xmemdup(src.data, src.size);
for (size_t i = first - p; i < length; ++i)
for (size_t i = first - src.data; i < src.size; ++i)
if (char_is_non_printable(dest[i]))
dest[i] = ' ';
return { dest, length };
return { dest, src.size };
}
WritableBuffer<char>
FixTagString(const char *p, size_t length)
FixTagString(StringView p)
{
auto utf8 = fix_utf8(p, length);
if (!utf8.IsNull()) {
p = utf8.data;
length = utf8.size;
}
auto utf8 = fix_utf8(p);
if (!utf8.IsNull())
p = {utf8.data, utf8.size};
WritableBuffer<char> cleared = clear_non_printable(p, length);
WritableBuffer<char> cleared = clear_non_printable(p);
if (cleared.IsNull())
cleared = utf8;
else

3
src/tag/TagString.hxx
View File

@ -25,10 +25,11 @@
#include <stddef.h>
struct StringView;
template<typename T> struct WritableBuffer;
gcc_nonnull_all
WritableBuffer<char>
FixTagString(const char *p, size_t length);
FixTagString(StringView p);
#endif

108
src/util/StringView.hxx Normal file
View File

@ -0,0 +1,108 @@
/*
* Copyright (C) 2013-2015 Max Kellermann <max@duempel.org>
*
* 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.
*
* 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
* FOUNDATION 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.
*/
#ifndef STRING_VIEW_HXX
#define STRING_VIEW_HXX
#include "ConstBuffer.hxx"
#include <string.h>
struct StringView : ConstBuffer<char> {
StringView() = default;
constexpr StringView(pointer_type _data, size_type _size)
:ConstBuffer<char>(_data, _size) {}
constexpr StringView(pointer_type _begin, pointer_type _end)
:ConstBuffer<char>(_begin, _end - _begin) {}
StringView(pointer_type _data)
:ConstBuffer<char>(_data,
_data != nullptr ? strlen(_data) : 0) {}
StringView(std::nullptr_t n)
:ConstBuffer<char>(n) {}
static constexpr StringView Empty() {
return StringView("", size_t(0));
}
void SetEmpty() {
data = "";
size = 0;
}
gcc_pure
pointer_type Find(char ch) const {
return (pointer_type)memchr(data, ch, size);
}
StringView &operator=(std::nullptr_t) {
data = nullptr;
size = 0;
return *this;
}
StringView &operator=(pointer_type _data) {
data = _data;
size = _data != nullptr ? strlen(_data) : 0;
return *this;
}
gcc_pure
bool StartsWith(StringView needle) const {
return size >= needle.size &&
memcmp(data, needle.data, needle.size) == 0;
}
gcc_pure
bool Equals(StringView other) const {
return size == other.size &&
memcmp(data, other.data, size) == 0;
}
template<size_t n>
bool EqualsLiteral(const char (&other)[n]) const {
return Equals({other, n - 1});
}
gcc_pure
bool EqualsIgnoreCase(StringView other) const {
return size == other.size &&
strncasecmp(data, other.data, size) == 0;
}
template<size_t n>
bool EqualsLiteralIgnoreCase(const char (&other)[n]) const {
return EqualsIgnoreCase({other, n - 1});
}
};
#endif