aboutsummaryrefslogtreecommitdiffstats
path: root/lv2/lv2plug.in/ns/ext/atom
diff options
context:
space:
mode:
authorDavid Robillard <d@drobilla.net>2012-04-12 02:39:05 +0000
committerDavid Robillard <d@drobilla.net>2012-04-12 02:39:05 +0000
commitf0f9e67865ff9beb323ad1acab4d0136ea08c38f (patch)
treeb0cc5580f43a4d128e9444df42e8e6acd14b002e /lv2/lv2plug.in/ns/ext/atom
parentcb1eb8a0ac422f64f7be787826f6ab37343de850 (diff)
downloadlv2-f0f9e67865ff9beb323ad1acab4d0136ea08c38f.tar.xz
Make all atom/util.h functions start with lv2_atom.
Diffstat (limited to 'lv2/lv2plug.in/ns/ext/atom')
-rw-r--r--lv2/lv2plug.in/ns/ext/atom/atom-test.c60
-rw-r--r--lv2/lv2plug.in/ns/ext/atom/util.h220
2 files changed, 108 insertions, 172 deletions
diff --git a/lv2/lv2plug.in/ns/ext/atom/atom-test.c b/lv2/lv2plug.in/ns/ext/atom/atom-test.c
index 931fde1..d2762f3 100644
--- a/lv2/lv2plug.in/ns/ext/atom/atom-test.c
+++ b/lv2/lv2plug.in/ns/ext/atom/atom-test.c
@@ -203,24 +203,24 @@ main()
LV2_Atom_Bool* tup1 = (LV2_Atom_Bool*)lv2_atom_forge_deref(
&forge, lv2_atom_forge_bool(&forge, true));
lv2_atom_forge_pop(&forge, &tuple_frame);
- LV2_Atom_Tuple_Iter i = lv2_tuple_begin(tuple);
- if (lv2_tuple_is_end(tuple, i)) {
+ LV2_Atom* i = lv2_atom_tuple_begin(tuple);
+ if (lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), tuple->atom.size, i)) {
return test_fail("Tuple iterator is empty\n");
}
- LV2_Atom* tup0i = (LV2_Atom*)lv2_tuple_iter_get(i);
+ LV2_Atom* tup0i = i;
if (!lv2_atom_equals((LV2_Atom*)tup0, tup0i)) {
return test_fail("Corrupt tuple element 0\n");
}
- i = lv2_tuple_iter_next(i);
- if (lv2_tuple_is_end(tuple, i)) {
+ i = lv2_atom_tuple_next(i);
+ if (lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), tuple->atom.size, i)) {
return test_fail("Premature end of tuple iterator\n");
}
- LV2_Atom* tup1i = lv2_tuple_iter_get(i);
+ LV2_Atom* tup1i = i;
if (!lv2_atom_equals((LV2_Atom*)tup1, tup1i)) {
return test_fail("Corrupt tuple element 1\n");
}
- i = lv2_tuple_iter_next(i);
- if (!lv2_tuple_is_end(tuple, i)) {
+ i = lv2_atom_tuple_next(i);
+ if (!lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), tuple->atom.size, i)) {
return test_fail("Tuple iter is not at end\n");
}
@@ -273,8 +273,7 @@ main()
}
unsigned n_events = 0;
- LV2_SEQUENCE_FOREACH(seq, i) {
- LV2_Atom_Event* ev = lv2_sequence_iter_get(i);
+ LV2_ATOM_SEQUENCE_FOREACH(seq, ev) {
if (ev->time.frames != n_events) {
return test_fail("Corrupt event %u has bad time\n", n_events);
} else if (ev->body.type != forge.Int) {
@@ -286,8 +285,7 @@ main()
}
unsigned n_props = 0;
- LV2_OBJECT_FOREACH((LV2_Atom_Object*)obj, i) {
- LV2_Atom_Property_Body* prop = lv2_object_iter_get(i);
+ LV2_ATOM_OBJECT_FOREACH((LV2_Atom_Object*)obj, prop) {
if (!prop->key) {
return test_fail("Corrupt property %u has no key\n", n_props);
} else if (prop->context) {
@@ -337,10 +335,10 @@ main()
{ eg_vector, &matches.vector },
{ eg_vector2, &matches.vector2 },
{ eg_seq, &matches.seq },
- LV2_OBJECT_QUERY_END
+ LV2_ATOM_OBJECT_QUERY_END
};
- unsigned n_matches = lv2_object_query((LV2_Atom_Object*)obj, q);
+ unsigned n_matches = lv2_atom_object_query((LV2_Atom_Object*)obj, q);
for (int i = 0; i < 2; ++i) {
if (n_matches != n_props) {
return test_fail("Query failed, %u matches != %u\n",
@@ -375,23 +373,23 @@ main()
return test_fail("Bad match sequence\n");
}
memset(&matches, 0, sizeof(matches));
- n_matches = lv2_object_get((LV2_Atom_Object*)obj,
- eg_one, &matches.one,
- eg_two, &matches.two,
- eg_three, &matches.three,
- eg_four, &matches.four,
- eg_true, &matches.affirmative,
- eg_false, &matches.negative,
- eg_path, &matches.path,
- eg_uri, &matches.uri,
- eg_urid, &matches.urid,
- eg_string, &matches.string,
- eg_literal, &matches.literal,
- eg_tuple, &matches.tuple,
- eg_vector, &matches.vector,
- eg_vector2, &matches.vector2,
- eg_seq, &matches.seq,
- 0);
+ n_matches = lv2_atom_object_get((LV2_Atom_Object*)obj,
+ eg_one, &matches.one,
+ eg_two, &matches.two,
+ eg_three, &matches.three,
+ eg_four, &matches.four,
+ eg_true, &matches.affirmative,
+ eg_false, &matches.negative,
+ eg_path, &matches.path,
+ eg_uri, &matches.uri,
+ eg_urid, &matches.urid,
+ eg_string, &matches.string,
+ eg_literal, &matches.literal,
+ eg_tuple, &matches.tuple,
+ eg_vector, &matches.vector,
+ eg_vector2, &matches.vector2,
+ eg_seq, &matches.seq,
+ 0);
}
printf("All tests passed.\n");
diff --git a/lv2/lv2plug.in/ns/ext/atom/util.h b/lv2/lv2plug.in/ns/ext/atom/util.h
index 6b46a67..f7fd35f 100644
--- a/lv2/lv2plug.in/ns/ext/atom/util.h
+++ b/lv2/lv2plug.in/ns/ext/atom/util.h
@@ -72,78 +72,60 @@ lv2_atom_equals(const LV2_Atom* a, const LV2_Atom* b)
@{
*/
-/** An iterator over the elements of an LV2_Atom_Sequence. */
-typedef LV2_Atom_Event* LV2_Atom_Sequence_Iter;
-
-/** Get an iterator pointing to the first element in a Sequence body. */
-static inline LV2_Atom_Sequence_Iter
-lv2_sequence_body_begin(const LV2_Atom_Sequence_Body* body)
+/** Get an iterator pointing to the first event in a Sequence body. */
+static inline LV2_Atom_Event*
+lv2_atom_sequence_begin(const LV2_Atom_Sequence_Body* body)
{
- return (LV2_Atom_Sequence_Iter)(body + 1);
+ return (LV2_Atom_Event*)(body + 1);
}
-/** Get an iterator pointing to the first element in a Sequence. */
-static inline LV2_Atom_Sequence_Iter
-lv2_sequence_begin(const LV2_Atom_Sequence* seq)
+/** Get an iterator pointing to the end of a Sequence body. */
+static inline LV2_Atom_Event*
+lv2_atom_sequence_end(const LV2_Atom_Sequence_Body* body, uint32_t size)
{
- return (LV2_Atom_Sequence_Iter)(seq + 1);
+ return (LV2_Atom_Event*)(body + lv2_atom_pad_size(size));
}
/** Return true iff @p i has reached the end of @p body. */
static inline bool
-lv2_sequence_body_is_end(const LV2_Atom_Sequence_Body* body,
+lv2_atom_sequence_is_end(const LV2_Atom_Sequence_Body* body,
uint32_t size,
- LV2_Atom_Sequence_Iter i)
+ LV2_Atom_Event* i)
{
return (uint8_t*)i >= ((uint8_t*)body + size);
}
-/** Return true iff @p i has reached the end of @p seq. */
-static inline bool
-lv2_sequence_is_end(const LV2_Atom_Sequence* seq, LV2_Atom_Sequence_Iter i)
-{
- return (uint8_t*)i >= ((uint8_t*)seq + sizeof(LV2_Atom) + seq->atom.size);
-}
-
/** Return an iterator to the element following @p i. */
-static inline LV2_Atom_Sequence_Iter
-lv2_sequence_iter_next(const LV2_Atom_Sequence_Iter i)
-{
- return (LV2_Atom_Sequence_Iter)((uint8_t*)i
- + sizeof(LV2_Atom_Event)
- + lv2_atom_pad_size(i->body.size));
-}
-
-/** Return the element pointed to by @p i. */
static inline LV2_Atom_Event*
-lv2_sequence_iter_get(LV2_Atom_Sequence_Iter i)
+lv2_atom_sequence_next(const LV2_Atom_Event* i)
{
- return (LV2_Atom_Event*)i;
+ return (LV2_Atom_Event*)((uint8_t*)i
+ + sizeof(LV2_Atom_Event)
+ + lv2_atom_pad_size(i->body.size));
}
/**
A macro for iterating over all events in a Sequence.
- @param sequence The sequence to iterate over
+ @param seq The sequence to iterate over
@param iter The name of the iterator
This macro is used similarly to a for loop (which it expands to), e.g.:
@code
- LV2_SEQUENCE_FOREACH(sequence, i) {
- LV2_Atom_Event* ev = lv2_sequence_iter_get(i);
- // Do something with ev here...
+ LV2_ATOM_SEQUENCE_FOREACH(sequence, ev) {
+ // Do something with ev (an LV2_Atom_Event*) here...
}
@endcode
*/
-#define LV2_SEQUENCE_FOREACH(sequence, iter) \
- for (LV2_Atom_Sequence_Iter (iter) = lv2_sequence_begin(sequence); \
- !lv2_sequence_is_end(sequence, (iter)); \
- (iter) = lv2_sequence_iter_next(iter))
+#define LV2_ATOM_SEQUENCE_FOREACH(seq, iter) \
+ for (LV2_Atom_Event* (iter) = lv2_atom_sequence_begin(&(seq)->body); \
+ !lv2_atom_sequence_is_end(&(seq)->body, (seq)->atom.size, (iter)); \
+ (iter) = lv2_atom_sequence_next(iter))
-/** A version of LV2_SEQUENCE_FOREACH for when only the body is available. */
-#define LV2_SEQUENCE_BODY_FOREACH(body, size, iter) \
- for (LV2_Atom_Sequence_Iter (iter) = lv2_sequence_body_begin(body); \
- !lv2_sequence_body_is_end(body, size, (iter)); \
- (iter) = lv2_sequence_iter_next(iter))
+/** Like LV2_ATOM_SEQUENCE_FOREACH but for a headerless sequence body. */
+#define LV2_ATOM_SEQUENCE_BODY_FOREACH(body, size, iter) \
+ for (LV2_Atom_Event* (iter) = lv2_atom_sequence_begin(body); \
+ !lv2_atom_sequence_is_end(body, size, (iter)); \
+ (iter) = lv2_atom_sequence_next(iter))
/**
@}
@@ -151,45 +133,26 @@ lv2_sequence_iter_get(LV2_Atom_Sequence_Iter i)
@{
*/
-/** An iterator over the elements of an LV2_Atom_Tuple. */
-typedef LV2_Atom* LV2_Atom_Tuple_Iter;
-
/** Get an iterator pointing to the first element in @p tup. */
-static inline LV2_Atom_Tuple_Iter
-lv2_tuple_begin(const LV2_Atom_Tuple* tup)
+static inline LV2_Atom*
+lv2_atom_tuple_begin(const LV2_Atom_Tuple* tup)
{
- return (LV2_Atom_Tuple_Iter)(LV2_ATOM_BODY(tup));
+ return (LV2_Atom*)(LV2_ATOM_BODY(tup));
}
/** Return true iff @p i has reached the end of @p body. */
static inline bool
-lv2_atom_tuple_body_is_end(const void* body,
- uint32_t size,
- LV2_Atom_Tuple_Iter i)
+lv2_atom_tuple_is_end(const void* body, uint32_t size, LV2_Atom* i)
{
return (uint8_t*)i >= ((uint8_t*)body + size);
}
-/** Return true iff @p i has reached the end of @p tup. */
-static inline bool
-lv2_tuple_is_end(const LV2_Atom_Tuple* tup, LV2_Atom_Tuple_Iter i)
-{
- return lv2_atom_tuple_body_is_end(LV2_ATOM_BODY(tup), tup->atom.size, i);
-}
-
/** Return an iterator to the element following @p i. */
-static inline LV2_Atom_Tuple_Iter
-lv2_tuple_iter_next(const LV2_Atom_Tuple_Iter i)
-{
- return (LV2_Atom_Tuple_Iter)(
- (uint8_t*)i + sizeof(LV2_Atom) + lv2_atom_pad_size(i->size));
-}
-
-/** Return the element pointed to by @p i. */
static inline LV2_Atom*
-lv2_tuple_iter_get(LV2_Atom_Tuple_Iter i)
+lv2_atom_tuple_next(const LV2_Atom* i)
{
- return (LV2_Atom*)i;
+ return (LV2_Atom*)(
+ (uint8_t*)i + sizeof(LV2_Atom) + lv2_atom_pad_size(i->size));
}
/**
@@ -199,22 +162,21 @@ lv2_tuple_iter_get(LV2_Atom_Tuple_Iter i)
This macro is used similarly to a for loop (which it expands to), e.g.:
@code
- LV2_TUPLE_FOREACH(tuple, i) {
- LV2_Atom* elem = lv2_tuple_iter_get(i);
- // Do something with elem here...
+ LV2_ATOMO_TUPLE_FOREACH(tuple, elem) {
+ // Do something with elem (an LV2_Atom*) here...
}
@endcode
*/
-#define LV2_TUPLE_FOREACH(tuple, iter) \
- for (LV2_Atom_Tuple_Iter (iter) = lv2_tuple_begin(tuple); \
- !lv2_tuple_is_end(tuple, (iter)); \
- (iter) = lv2_tuple_iter_next(iter))
+#define LV2_ATOM_TUPLE_FOREACH(tuple, iter) \
+ for (LV2_Atom* (iter) = lv2_atom_tuple_begin(tuple); \
+ !lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), (tuple)->size, (iter)); \
+ (iter) = lv2_atom_tuple_next(iter))
-/** A version of LV2_TUPLE_FOREACH for when only the body is available. */
-#define LV2_TUPLE_BODY_FOREACH(body, size, iter) \
- for (LV2_Atom_Tuple_Iter (iter) = (LV2_Atom_Tuple_Iter)body; \
- !lv2_atom_tuple_body_is_end(body, size, (iter)); \
- (iter) = lv2_tuple_iter_next(iter))
+/** Like LV2_ATOM_TUPLE_FOREACH but for a headerless tuple body. */
+#define LV2_ATOM_TUPLE_BODY_FOREACH(body, size, iter) \
+ for (LV2_Atom* (iter) = (LV2_Atom*)body; \
+ !lv2_atom_tuple_is_end(body, size, (iter)); \
+ (iter) = lv2_atom_tuple_next(iter))
/**
@}
@@ -222,54 +184,32 @@ lv2_tuple_iter_get(LV2_Atom_Tuple_Iter i)
@{
*/
-/** An iterator over the properties of an LV2_Atom_Object. */
-typedef LV2_Atom_Property_Body* LV2_Atom_Object_Iter;
-
-static inline LV2_Atom_Object_Iter
-lv2_object_body_begin(const LV2_Atom_Object_Body* body)
-{
- return (LV2_Atom_Object_Iter)(body + 1);
-}
-
-/** Get an iterator pointing to the first property in @p obj. */
-static inline LV2_Atom_Object_Iter
-lv2_object_begin(const LV2_Atom_Object* obj)
-{
- return (LV2_Atom_Object_Iter)(obj + 1);
-}
-
-static inline bool
-lv2_atom_object_body_is_end(const LV2_Atom_Object_Body* body,
- uint32_t size,
- LV2_Atom_Object_Iter i)
+/** Return a pointer to the first property in @p body. */
+static inline LV2_Atom_Property_Body*
+lv2_atom_object_begin(const LV2_Atom_Object_Body* body)
{
- return (uint8_t*)i >= ((uint8_t*)body + size);
+ return (LV2_Atom_Property_Body*)(body + 1);
}
/** Return true iff @p i has reached the end of @p obj. */
static inline bool
-lv2_object_is_end(const LV2_Atom_Object* obj, LV2_Atom_Object_Iter i)
+lv2_atom_object_is_end(const LV2_Atom_Object_Body* body,
+ uint32_t size,
+ LV2_Atom_Property_Body* i)
{
- return (uint8_t*)i >= ((uint8_t*)obj + sizeof(LV2_Atom) + obj->atom.size);
+ return (uint8_t*)i >= ((uint8_t*)body + size);
}
/** Return an iterator to the property following @p i. */
-static inline LV2_Atom_Object_Iter
-lv2_object_iter_next(const LV2_Atom_Object_Iter i)
+static inline LV2_Atom_Property_Body*
+lv2_atom_object_next(const LV2_Atom_Property_Body* i)
{
const LV2_Atom* const value = (LV2_Atom*)((uint8_t*)i + sizeof(i));
- return (LV2_Atom_Object_Iter)((uint8_t*)i
+ return (LV2_Atom_Property_Body*)((uint8_t*)i
+ sizeof(LV2_Atom_Property_Body)
+ lv2_atom_pad_size(value->size));
}
-/** Return the property pointed to by @p i. */
-static inline LV2_Atom_Property_Body*
-lv2_object_iter_get(LV2_Atom_Object_Iter i)
-{
- return (LV2_Atom_Property_Body*)i;
-}
-
/**
A macro for iterating over all properties of an Object.
@param object The object to iterate over
@@ -277,22 +217,21 @@ lv2_object_iter_get(LV2_Atom_Object_Iter i)
This macro is used similarly to a for loop (which it expands to), e.g.:
@code
- LV2_OBJECT_FOREACH(object, i) {
- LV2_Atom_Property_Body* prop = lv2_object_iter_get(i);
- // Do something with prop here...
+ LV2_ATOM_OBJECT_FOREACH(object, i) {
+ // Do something with prop (an LV2_Atom_Property_Body*) here...
}
@endcode
*/
-#define LV2_OBJECT_FOREACH(object, iter) \
- for (LV2_Atom_Object_Iter (iter) = lv2_object_begin(object); \
- !lv2_object_is_end(object, (iter)); \
- (iter) = lv2_object_iter_next(iter))
+#define LV2_ATOM_OBJECT_FOREACH(obj, iter) \
+ for (LV2_Atom_Property_Body* (iter) = lv2_atom_object_begin(&(obj)->body); \
+ !lv2_atom_object_is_end(&(obj)->body, (obj)->atom.size, (iter)); \
+ (iter) = lv2_atom_object_next(iter))
-/** A version of LV2_OBJECT_FOREACH for when only the body is available. */
-#define LV2_OBJECT_BODY_FOREACH(body, size, iter) \
- for (LV2_Atom_Object_Iter (iter) = lv2_object_body_begin(body); \
- !lv2_atom_object_body_is_end(body, size, (iter)); \
- (iter) = lv2_object_iter_next(iter))
+/** Like LV2_ATOM_OBJECT_FOREACH but for a headerless object body. */
+#define LV2_ATOM_OBJECT_BODY_FOREACH(body, size, iter) \
+ for (LV2_Atom_Property_Body* (iter) = lv2_atom_object_begin(body); \
+ !lv2_atom_object_is_end(body, size, (iter)); \
+ (iter) = lv2_atom_object_next(iter))
/**
@}
@@ -306,7 +245,7 @@ typedef struct {
const LV2_Atom** value; /**< Found value (output set by query function) */
} LV2_Atom_Object_Query;
-static const LV2_Atom_Object_Query LV2_OBJECT_QUERY_END = { 0, NULL };
+static const LV2_Atom_Object_Query LV2_ATOM_OBJECT_QUERY_END = { 0, NULL };
/**
Get an object's values for various keys.
@@ -327,14 +266,15 @@ static const LV2_Atom_Object_Query LV2_OBJECT_QUERY_END = { 0, NULL };
LV2_Atom_Object_Query q[] = {
{ urids.eg_name, &name },
{ urids.eg_age, &age },
- LV2_OBJECT_QUERY_END
+ LV2_ATOM_OBJECT_QUERY_END
};
- lv2_object_query(obj, q);
+ lv2_atom_object_query(obj, q);
// name and age are now set to the appropriate values in obj, or NULL.
@endcode
*/
static inline int
-lv2_object_query(const LV2_Atom_Object* object, LV2_Atom_Object_Query* query)
+lv2_atom_object_query(const LV2_Atom_Object* object,
+ LV2_Atom_Object_Query* query)
{
int matches = 0;
int n_queries = 0;
@@ -344,8 +284,7 @@ lv2_object_query(const LV2_Atom_Object* object, LV2_Atom_Object_Query* query)
++n_queries;
}
- LV2_OBJECT_FOREACH(object, o) {
- const LV2_Atom_Property_Body* prop = lv2_object_iter_get(o);
+ LV2_ATOM_OBJECT_FOREACH(object, prop) {
for (LV2_Atom_Object_Query* q = query; q->key; ++q) {
if (q->key == prop->key && !*q->value) {
*q->value = &prop->value;
@@ -360,7 +299,7 @@ lv2_object_query(const LV2_Atom_Object* object, LV2_Atom_Object_Query* query)
}
/**
- Variable argument version of lv2_object_get().
+ Variable argument version of lv2_atom_object_get().
This is nicer-looking in code, but a bit more error-prone since it is not
type safe and the argument list must be terminated.
@@ -372,14 +311,14 @@ lv2_object_query(const LV2_Atom_Object* object, LV2_Atom_Object_Query* query)
@code
const LV2_Atom* name = NULL;
const LV2_Atom* age = NULL;
- lv2_object_get(obj,
- uris.name_key, &name,
- uris.age_key, &age,
- 0);
+ lv2_atom_object_get(obj,
+ uris.name_key, &name,
+ uris.age_key, &age,
+ 0);
@endcode
*/
static inline int
-lv2_object_get(const LV2_Atom_Object* object, ...)
+lv2_atom_object_get(const LV2_Atom_Object* object, ...)
{
int matches = 0;
int n_queries = 0;
@@ -394,8 +333,7 @@ lv2_object_get(const LV2_Atom_Object* object, ...)
}
va_end(args);
- LV2_OBJECT_FOREACH(object, o) {
- const LV2_Atom_Property_Body* prop = lv2_object_iter_get(o);
+ LV2_ATOM_OBJECT_FOREACH(object, prop) {
va_start(args, object);
for (int i = 0; i < n_queries; ++i) {
uint32_t qkey = va_arg(args, uint32_t);