aboutsummaryrefslogtreecommitdiffstats
path: root/ext/atom.lv2/atom-helpers.h
diff options
context:
space:
mode:
Diffstat (limited to 'ext/atom.lv2/atom-helpers.h')
-rw-r--r--ext/atom.lv2/atom-helpers.h142
1 files changed, 71 insertions, 71 deletions
diff --git a/ext/atom.lv2/atom-helpers.h b/ext/atom.lv2/atom-helpers.h
index f2717a3..b58fa09 100644
--- a/ext/atom.lv2/atom-helpers.h
+++ b/ext/atom.lv2/atom-helpers.h
@@ -1,42 +1,38 @@
-/* lv2_atom_helpers.h - Helper functions for the LV2 atoms extension.
- * Copyright (C) 2008-2010 David Robillard <http://drobilla.net>
- *
- * This header is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This header is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this header; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307 USA
- */
+/*
+ Copyright 2008-2011 David Robillard <http://drobilla.net>
+
+ Permission to use, copy, modify, and/or distribute this software for any
+ purpose with or without fee is hereby granted, provided that the above
+ copyright notice and this permission notice appear in all copies.
+
+ THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/**
+ @file atom-helpers.h Helper functions for the LV2 Atom extension.
+
+ These functions are provided for convenience only, use of them is not
+ required for supporting atoms.
+
+ Note that these functions are all static inline which basically means:
+ do not take the address of these functions.
+*/
#ifndef LV2_ATOM_HELPERS_H
#define LV2_ATOM_HELPERS_H
-#include <stdint.h>
#include <stdbool.h>
-#include <string.h>
+#include <stdint.h>
#include <stdio.h>
-#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
-
-/** @file
- * Helper functions for the LV2 Atom extension
- * <http://lv2plug.in/ns/ext/atom>.
- *
- * These functions are provided for convenience only, use of them is not
- * required for supporting atoms (i.e. the definition of atoms in memory
- * is described in atom.h and NOT by this API).
- *
- * Note that these functions are all static inline which basically means:
- * do not take the address of these functions.
- */
+#include <string.h>
+#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
/** Pad a size to 4 bytes (32 bits) */
static inline uint16_t
@@ -47,28 +43,28 @@ lv2_atom_pad_size(uint16_t size)
typedef LV2_Atom_Property* LV2_Object_Iter;
-/** Get an iterator pointing to @a prop in some LV2_Object */
+/** Get an iterator pointing to @c prop in some LV2_Object */
static inline LV2_Object_Iter
lv2_object_begin(const LV2_Atom* obj)
{
return (LV2_Object_Iter)(((const LV2_Object*)obj->body)->properties);
}
-/** Return true iff @a iter has reached the end of @a object */
+/** Return true iff @c iter has reached the end of @c object */
static inline bool
lv2_object_iter_is_end(const LV2_Atom* object, LV2_Object_Iter iter)
{
return (uint8_t*)iter >= ((uint8_t*)object->body + object->size);
}
-/** Return true iff @a l points to the same property as @a r */
+/** Return true iff @c l points to the same property as @c r */
static inline bool
lv2_object_iter_equals(const LV2_Object_Iter l, const LV2_Object_Iter r)
{
return l == r;
}
-/** Return an iterator to the property following @a iter */
+/** Return an iterator to the property following @c iter */
static inline LV2_Object_Iter
lv2_object_iter_next(const LV2_Object_Iter iter)
{
@@ -76,42 +72,45 @@ lv2_object_iter_next(const LV2_Object_Iter iter)
(uint8_t*)iter + sizeof(LV2_Atom_Property) + lv2_atom_pad_size(iter->value.size));
}
-/** Return the property pointed to by @a iter */
+/** Return the property pointed to by @c iter */
static inline LV2_Atom_Property*
lv2_object_iter_get(LV2_Object_Iter iter)
{
return (LV2_Atom_Property*)iter;
}
-/** A macro for iterating over all properties of an Object.
- * @param obj The object 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.:
- * <pre>
- * LV2_OBJECT_FOREACH(object, i) {
- * LV2_Atom_Property* prop = lv2_object_iter_get(i);
- * // Do things with prop here...
- * }
- * </pre>
- */
+/**
+ A macro for iterating over all properties of an Object.
+ @param obj The object 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.:
+ <pre>
+ LV2_OBJECT_FOREACH(object, i) {
+ LV2_Atom_Property* prop = lv2_object_iter_get(i);
+ // Do things with prop here...
+ }
+ </pre>
+*/
#define LV2_OBJECT_FOREACH(obj, iter) \
for (LV2_Object_Iter (iter) = lv2_object_begin(obj); \
!lv2_object_iter_is_end(obj, (iter)); \
(iter) = lv2_object_iter_next(iter))
-/** Append a Property body to an Atom that contains properties (e.g. atom:Object).
- * This function will write the property body (not including an LV2_Object
- * header) at lv2_atom_pad_size(body + size). Thus, it can be used with any
- * Atom type that contains headerless 32-bit aligned properties.
- * @param object Pointer to the atom that contains the property to add. object.size
- * must be valid, but object.type is ignored.
- * @param key The key of the new property
- * @param value_type The type of the new value
- * @param value_size The size of the new value
- * @param value_body Pointer to the new value's data
- * @return a pointer to the new LV2_Atom_Property in @a body.
- */
+/**
+ Append a Property body to an Atom that contains properties (e.g. atom:Object).
+ @param object Pointer to the atom that contains the property to add. object.size
+ must be valid, but object.type is ignored.
+ @param key The key of the new property
+ @param value_type The type of the new value
+ @param value_size The size of the new value
+ @param value_body Pointer to the new value's data
+ @return a pointer to the new LV2_Atom_Property in @c body.
+
+ This function will write the property body (not including an LV2_Object
+ header) at lv2_atom_pad_size(body + size). Thus, it can be used with any
+ Atom type that contains headerless 32-bit aligned properties.
+*/
static inline LV2_Atom_Property*
lv2_atom_append_property(LV2_Atom* object,
uint32_t key,
@@ -129,14 +128,14 @@ lv2_atom_append_property(LV2_Atom* object,
return prop;
}
-/** Return true iff @a atom is NULL */
+/** Return true iff @c atom is NULL */
static inline bool
lv2_atom_is_null(LV2_Atom* atom)
{
return !atom || (atom->type == 0 && atom->size == 0);
}
-/** Return true iff @a object has rdf:type @a type */
+/** Return true iff @c object has rdf:type @c type */
static inline bool
lv2_atom_is_a(LV2_Atom* object,
uint32_t rdf_type,
@@ -174,13 +173,15 @@ typedef struct {
const LV2_Atom* value; ///< Possibly set by query function to the found value
} LV2_Object_Query;
-/** "Query" an object, getting a pointer to the values for various keys.
- * The value pointer of each item in @a q will be set to the location of
- * the corresponding value in @a object. Every value pointer in @a query
- * MUST be initialised to NULL. This function reads @a object in a single
- * linear sweep. By allocating @a q on the stack, objects can be "queried"
- * quickly without allocating any memory. This function is realtime safe.
- */
+/**
+ "Query" an object, getting a pointer to the values for various keys.
+
+ The value pointer of each item in @c query will be set to the location of
+ the corresponding value in @c object. Every value pointer in @c query MUST
+ be initialised to NULL. This function reads @c object in a single linear
+ sweep. By allocating @c query on the stack, objects can be "queried"
+ quickly without allocating any memory. This function is realtime safe.
+*/
static inline int
lv2_object_query(const LV2_Atom* object, LV2_Object_Query* query)
{
@@ -206,4 +207,3 @@ lv2_object_query(const LV2_Atom* object, LV2_Object_Query* query)
}
#endif /* LV2_ATOM_HELPERS_H */
-