2020-09-29 14:42:22 +00:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
shared: add NMRefString
I'd like to refactor libnm's caching. Note that cached D-Bus objects
have repeated strings all over the place. For example every object will
have a set of D-Bus interfaces (strings) and properties (strings) and an
object path (which is referenced by other objects). We can save a lot of
redundant strings by deduplicating/interning them. Also, by interning
them, we can compare them using pointer equality.
Add a NMRefString implementation for this.
Maybe an alternative name would be NMInternedString or NMDedupString, because
this string gets always interned. There is no way to create a NMRefString
that is not interned. Still, NMRefString name sounds better. It is ref-counted
after all.
Notes:
- glib has GQuark and g_intern_string(). However, such strings cannot
be unrefered and are leaked indefinitely. It is thus unsuited for
anything but a fixed set of well-known strings.
- glib 2.58 adds GRefString, but we cannot use that because we
currently still use glib 2.40.
There are some differences:
- GRefString is just a typedef to char. That means, the glib API
exposes GRefString like regular character strings.
NMRefString intentionally does that not. This makes it slightly
less convenient to pass it to API that expects "const char *".
But it makes it clear to the reader, that an instance is in fact
a NMRefString, which means it indicates that the string is
interned and can be referenced without additional copy.
- GRefString can be optionally interned. That means you can
only use pointer equality for comparing values if you know
that the GRefString was created with g_ref_string_new_intern().
So, GRefString looks like a "const char *" pointer and even if
you know it's a GRefString, you might not know whether it is
interned. NMRefString is always interned, and you can always
compare it using pointer equality.
- In the past I already proposed a different implementation for a
ref-string. That made different choices. For example NMRefString
then was a typedef to "const char *", it did not support interning
but deduplication (without a global cache), ref/unref was not
thread safe (but then there was no global cache so that two threads
could still use the API independently).
The point is, there are various choices to make. GRefString, the
previous NMRefString implementation and the one here, all have pros and
cons. I think for the purpose where I intend NMRefString (dedup and
efficient comparison), it is a preferable implementation.
Ah, and of course NMRefString is an immutable string, which is a nice
property.
2019-09-02 05:54:28 +00:00
|
|
|
|
|
|
|
|
#ifndef __NM_REF_STRING_H__
|
|
|
|
|
#define __NM_REF_STRING_H__
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
2019-10-16 06:55:45 +00:00
|
|
|
typedef struct _NMRefString {
|
shared: add NMRefString
I'd like to refactor libnm's caching. Note that cached D-Bus objects
have repeated strings all over the place. For example every object will
have a set of D-Bus interfaces (strings) and properties (strings) and an
object path (which is referenced by other objects). We can save a lot of
redundant strings by deduplicating/interning them. Also, by interning
them, we can compare them using pointer equality.
Add a NMRefString implementation for this.
Maybe an alternative name would be NMInternedString or NMDedupString, because
this string gets always interned. There is no way to create a NMRefString
that is not interned. Still, NMRefString name sounds better. It is ref-counted
after all.
Notes:
- glib has GQuark and g_intern_string(). However, such strings cannot
be unrefered and are leaked indefinitely. It is thus unsuited for
anything but a fixed set of well-known strings.
- glib 2.58 adds GRefString, but we cannot use that because we
currently still use glib 2.40.
There are some differences:
- GRefString is just a typedef to char. That means, the glib API
exposes GRefString like regular character strings.
NMRefString intentionally does that not. This makes it slightly
less convenient to pass it to API that expects "const char *".
But it makes it clear to the reader, that an instance is in fact
a NMRefString, which means it indicates that the string is
interned and can be referenced without additional copy.
- GRefString can be optionally interned. That means you can
only use pointer equality for comparing values if you know
that the GRefString was created with g_ref_string_new_intern().
So, GRefString looks like a "const char *" pointer and even if
you know it's a GRefString, you might not know whether it is
interned. NMRefString is always interned, and you can always
compare it using pointer equality.
- In the past I already proposed a different implementation for a
ref-string. That made different choices. For example NMRefString
then was a typedef to "const char *", it did not support interning
but deduplication (without a global cache), ref/unref was not
thread safe (but then there was no global cache so that two threads
could still use the API independently).
The point is, there are various choices to make. GRefString, the
previous NMRefString implementation and the one here, all have pros and
cons. I think for the purpose where I intend NMRefString (dedup and
efficient comparison), it is a preferable implementation.
Ah, and of course NMRefString is an immutable string, which is a nice
property.
2019-09-02 05:54:28 +00:00
|
|
|
const char *const str;
|
|
|
|
|
const gsize len;
|
|
|
|
|
} NMRefString;
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
|
|
NMRefString *nm_ref_string_new_len(const char *cstr, gsize len);
|
|
|
|
|
|
|
|
|
|
static inline NMRefString *
|
|
|
|
|
nm_ref_string_new(const char *cstr)
|
|
|
|
|
{
|
|
|
|
|
return cstr ? nm_ref_string_new_len(cstr, strlen(cstr)) : NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
NMRefString *nm_ref_string_ref(NMRefString *rstr);
|
|
|
|
|
void _nm_ref_string_unref_non_null(NMRefString *rstr);
|
|
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
|
nm_ref_string_unref(NMRefString *rstr)
|
|
|
|
|
{
|
|
|
|
|
if (rstr)
|
|
|
|
|
_nm_ref_string_unref_non_null(rstr);
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-19 09:40:50 +00:00
|
|
|
NM_AUTO_DEFINE_FCN_VOID0(NMRefString *, _nm_auto_ref_string, _nm_ref_string_unref_non_null);
|
shared: add NMRefString
I'd like to refactor libnm's caching. Note that cached D-Bus objects
have repeated strings all over the place. For example every object will
have a set of D-Bus interfaces (strings) and properties (strings) and an
object path (which is referenced by other objects). We can save a lot of
redundant strings by deduplicating/interning them. Also, by interning
them, we can compare them using pointer equality.
Add a NMRefString implementation for this.
Maybe an alternative name would be NMInternedString or NMDedupString, because
this string gets always interned. There is no way to create a NMRefString
that is not interned. Still, NMRefString name sounds better. It is ref-counted
after all.
Notes:
- glib has GQuark and g_intern_string(). However, such strings cannot
be unrefered and are leaked indefinitely. It is thus unsuited for
anything but a fixed set of well-known strings.
- glib 2.58 adds GRefString, but we cannot use that because we
currently still use glib 2.40.
There are some differences:
- GRefString is just a typedef to char. That means, the glib API
exposes GRefString like regular character strings.
NMRefString intentionally does that not. This makes it slightly
less convenient to pass it to API that expects "const char *".
But it makes it clear to the reader, that an instance is in fact
a NMRefString, which means it indicates that the string is
interned and can be referenced without additional copy.
- GRefString can be optionally interned. That means you can
only use pointer equality for comparing values if you know
that the GRefString was created with g_ref_string_new_intern().
So, GRefString looks like a "const char *" pointer and even if
you know it's a GRefString, you might not know whether it is
interned. NMRefString is always interned, and you can always
compare it using pointer equality.
- In the past I already proposed a different implementation for a
ref-string. That made different choices. For example NMRefString
then was a typedef to "const char *", it did not support interning
but deduplication (without a global cache), ref/unref was not
thread safe (but then there was no global cache so that two threads
could still use the API independently).
The point is, there are various choices to make. GRefString, the
previous NMRefString implementation and the one here, all have pros and
cons. I think for the purpose where I intend NMRefString (dedup and
efficient comparison), it is a preferable implementation.
Ah, and of course NMRefString is an immutable string, which is a nice
property.
2019-09-02 05:54:28 +00:00
|
|
|
#define nm_auto_ref_string nm_auto(_nm_auto_ref_string)
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
|
|
static inline const char *
|
|
|
|
|
nm_ref_string_get_str(NMRefString *rstr)
|
|
|
|
|
{
|
|
|
|
|
return rstr ? rstr->str : NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline gsize
|
|
|
|
|
nm_ref_string_get_len(NMRefString *rstr)
|
|
|
|
|
{
|
|
|
|
|
return rstr ? rstr->len : 0u;
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-29 16:46:22 +00:00
|
|
|
static inline gboolean
|
|
|
|
|
nm_ref_string_equals_str(NMRefString *rstr, const char *s)
|
|
|
|
|
{
|
|
|
|
|
/* Note that rstr->len might be greater than strlen(rstr->str). This function does
|
|
|
|
|
* not cover that and would ignore everything after the first NUL byte. If you need
|
|
|
|
|
* that distinction, this function is not for you. */
|
|
|
|
|
|
2020-03-02 14:48:43 +00:00
|
|
|
return rstr ? (s && nm_streq(rstr->str, s)) : (s == NULL);
|
2020-01-29 16:46:22 +00:00
|
|
|
}
|
|
|
|
|
|
2019-10-22 14:49:05 +00:00
|
|
|
static inline gboolean
|
|
|
|
|
NM_IS_REF_STRING(const NMRefString *rstr)
|
|
|
|
|
{
|
|
|
|
|
#if NM_MORE_ASSERTS > 10
|
|
|
|
|
if (rstr) {
|
|
|
|
|
nm_auto_ref_string NMRefString *r2 = NULL;
|
|
|
|
|
|
|
|
|
|
r2 = nm_ref_string_new_len(rstr->str, rstr->len);
|
|
|
|
|
nm_assert(rstr == r2);
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Technically, %NULL is also a valid NMRefString (according to nm_ref_string_new(),
|
|
|
|
|
* nm_ref_string_get_str() and nm_ref_string_unref()). However, NM_IS_REF_STRING()
|
|
|
|
|
* does not think so. If callers want to allow %NULL, they need to check
|
|
|
|
|
* separately. */
|
|
|
|
|
return !!rstr;
|
|
|
|
|
}
|
|
|
|
|
|
shared: add NMRefString
I'd like to refactor libnm's caching. Note that cached D-Bus objects
have repeated strings all over the place. For example every object will
have a set of D-Bus interfaces (strings) and properties (strings) and an
object path (which is referenced by other objects). We can save a lot of
redundant strings by deduplicating/interning them. Also, by interning
them, we can compare them using pointer equality.
Add a NMRefString implementation for this.
Maybe an alternative name would be NMInternedString or NMDedupString, because
this string gets always interned. There is no way to create a NMRefString
that is not interned. Still, NMRefString name sounds better. It is ref-counted
after all.
Notes:
- glib has GQuark and g_intern_string(). However, such strings cannot
be unrefered and are leaked indefinitely. It is thus unsuited for
anything but a fixed set of well-known strings.
- glib 2.58 adds GRefString, but we cannot use that because we
currently still use glib 2.40.
There are some differences:
- GRefString is just a typedef to char. That means, the glib API
exposes GRefString like regular character strings.
NMRefString intentionally does that not. This makes it slightly
less convenient to pass it to API that expects "const char *".
But it makes it clear to the reader, that an instance is in fact
a NMRefString, which means it indicates that the string is
interned and can be referenced without additional copy.
- GRefString can be optionally interned. That means you can
only use pointer equality for comparing values if you know
that the GRefString was created with g_ref_string_new_intern().
So, GRefString looks like a "const char *" pointer and even if
you know it's a GRefString, you might not know whether it is
interned. NMRefString is always interned, and you can always
compare it using pointer equality.
- In the past I already proposed a different implementation for a
ref-string. That made different choices. For example NMRefString
then was a typedef to "const char *", it did not support interning
but deduplication (without a global cache), ref/unref was not
thread safe (but then there was no global cache so that two threads
could still use the API independently).
The point is, there are various choices to make. GRefString, the
previous NMRefString implementation and the one here, all have pros and
cons. I think for the purpose where I intend NMRefString (dedup and
efficient comparison), it is a preferable implementation.
Ah, and of course NMRefString is an immutable string, which is a nice
property.
2019-09-02 05:54:28 +00:00
|
|
|
#endif /* __NM_REF_STRING_H__ */
|