From 6eb351aa82eb7eee4a78a9205cfd56ea9762e1ef Mon Sep 17 00:00:00 2001 From: David Robillard Date: Wed, 20 Oct 2010 02:13:36 +0000 Subject: Rename atom:Dict to atom:Object (more appropriate term since keys are restricted, matches JSON, kinda sorta matches RDF and intended usage). Rename atom:Array to atom:Tuple ("Array" seems to imply homogeneous and constant time indexing, which is not true here). --- ext/atom.lv2/atom-helpers.h | 36 ++++++++++++++++++------------------ ext/atom.lv2/atom.ttl | 17 +++++++++++------ 2 files changed, 29 insertions(+), 24 deletions(-) (limited to 'ext/atom.lv2') diff --git a/ext/atom.lv2/atom-helpers.h b/ext/atom.lv2/atom-helpers.h index e14a1e9..7b9275c 100644 --- a/ext/atom.lv2/atom-helpers.h +++ b/ext/atom.lv2/atom-helpers.h @@ -44,64 +44,64 @@ lv2_atom_pad_size(uint16_t size) return (size + 3) & (~3); } -typedef LV2_Atom_Property* LV2_Atom_Dict_Iter; +typedef LV2_Atom_Property* LV2_Atom_Object_Iter; -static inline LV2_Atom_Dict_Iter -lv2_atom_dict_get_iter(LV2_Atom_Property* prop) +static inline LV2_Atom_Object_Iter +lv2_atom_object_get_iter(LV2_Atom_Property* prop) { - return (LV2_Atom_Dict_Iter)prop; + return (LV2_Atom_Object_Iter)prop; } static inline bool -lv2_atom_dict_iter_is_end(const LV2_Atom* dict, LV2_Atom_Dict_Iter iter) +lv2_atom_object_iter_is_end(const LV2_Atom* object, LV2_Atom_Object_Iter iter) { - return (uint8_t*)iter >= (dict->body + dict->size); + return (uint8_t*)iter >= (object->body + object->size); } static inline bool -lv2_atom_dict_iter_equals(const LV2_Atom_Dict_Iter l, const LV2_Atom_Dict_Iter r) +lv2_atom_object_iter_equals(const LV2_Atom_Object_Iter l, const LV2_Atom_Object_Iter r) { return l == r; } -static inline LV2_Atom_Dict_Iter -lv2_atom_dict_iter_next(const LV2_Atom_Dict_Iter iter) +static inline LV2_Atom_Object_Iter +lv2_atom_object_iter_next(const LV2_Atom_Object_Iter iter) { - return (LV2_Atom_Dict_Iter)( + return (LV2_Atom_Object_Iter)( (uint8_t*)iter + sizeof(LV2_Atom_Property) + lv2_atom_pad_size(iter->object.size)); } static inline LV2_Atom_Property* -lv2_atom_dict_iter_get(LV2_Atom_Dict_Iter iter) +lv2_atom_object_iter_get(LV2_Atom_Object_Iter iter) { return (LV2_Atom_Property*)iter; } -/** Append a Property body to an Atom that contains properties (e.g. atom:Dict). +/** 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 64-bit aligned properties. - * @param dict Pointer to the atom that contains the property to add. dict.size - * must be valid, but dict.type is ignored. + * @param object Pointer to the atom that contains the property to add. object.size + * must be valid, but object.type is ignored. * @param size Must point to the size field of the container atom, and will be * padded up to 64 bits then increased by @a value_size. * @param body Must point to the body of the container atom. * @return a pointer to the new LV2_Atom_Property in @a body. */ static inline LV2_Atom_Property* -lv2_atom_append_property(LV2_Atom* dict, +lv2_atom_append_property(LV2_Atom* object, uint32_t key, uint16_t value_type, uint16_t value_size, const char* value_body) { - dict->size = lv2_atom_pad_size(dict->size); - LV2_Atom_Property* prop = (LV2_Atom_Property*)(dict->body + dict->size); + object->size = lv2_atom_pad_size(object->size); + LV2_Atom_Property* prop = (LV2_Atom_Property*)(object->body + object->size); prop->predicate = key; prop->object.type = value_type; prop->object.size = value_size; memcpy(prop->object.body, value_body, value_size); - dict->size += sizeof(uint32_t) + sizeof(LV2_Atom_Property) + value_size; + object->size += sizeof(uint32_t) + sizeof(LV2_Atom_Property) + value_size; return prop; } diff --git a/ext/atom.lv2/atom.ttl b/ext/atom.lv2/atom.ttl index 9158328..6e08359 100644 --- a/ext/atom.lv2/atom.ttl +++ b/ext/atom.lv2/atom.ttl @@ -142,11 +142,16 @@ vector, e.g. 
 uint16_t elem_size = (vector.size - (2 * sizeof(uint16_t))) / vector.count);
-Note that it is possible to construct a valid Atom for each element of the -vector, even by an implementation which does not understand type. +Note that it is possible to construct a valid Atom for each element +of the vector, even by an implementation which does not understand +elem_type. + +Note that an Atom is 32-bit aligned by definition, and both the Atom and +Vector headers are 32-bits each, therefore the first element of a Vector is +64-bit aligned. For example, an atom:Vector containing 42 elements of type atom:Int32 looks -like this in memory: +like this in memory (including the Atom header): 
 uint16_t atom_type    = uri_map(atom:Vector)
 uint16_t atom_size    = (2 * sizeof(uint16_t)) + (42 * sizeof(int32_t))
@@ -157,12 +162,12 @@ int32_t  contents[42] = ...
 """ .
 
 
-atom:Array a atom:AtomType ;
-	rdfs:label "Array" ;
+atom:Tuple a atom:AtomType ;
+	rdfs:label "Tuple" ;
     rdfs:comment """
 A POD sequence of atoms with varying types and sizes.
 
-The body of an array is simply a series of complete atoms, aligned to
+The body of a tuple is simply a series of complete atoms, aligned to
 32 bits.
 """ .
 
-- 
cgit v1.2.1