summaryrefslogtreecommitdiffstats
path: root/ingen
diff options
context:
space:
mode:
Diffstat (limited to 'ingen')
-rw-r--r--ingen/Atom.hpp166
1 files changed, 166 insertions, 0 deletions
diff --git a/ingen/Atom.hpp b/ingen/Atom.hpp
new file mode 100644
index 00000000..8e652e5e
--- /dev/null
+++ b/ingen/Atom.hpp
@@ -0,0 +1,166 @@
+/*
+ This file is part of Ingen.
+ Copyright 2007-2013 David Robillard <http://drobilla.net/>
+
+ Ingen is free software: you can redistribute it and/or modify it under the
+ terms of the GNU Affero General Public License as published by the Free
+ Software Foundation, either version 3 of the License, or any later version.
+
+ Ingen 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 Affero General Public License for details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with Ingen. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef INGEN_ATOM_HPP
+#define INGEN_ATOM_HPP
+
+#include <cassert>
+#include <cstring>
+#include <string>
+
+#include "lv2/lv2plug.in/ns/ext/atom/atom.h"
+#include "lv2/lv2plug.in/ns/ext/urid/urid.h"
+
+namespace Ingen {
+
+class Forge;
+
+/**
+ A generic typed data container.
+
+ An Atom holds a value with some type and size, both specified by a uint32_t.
+ Values with size less than sizeof(void*) are stored inline: no dynamic
+ allocation occurs so Atoms may be created in hard real-time threads.
+ Otherwise, if the size is larger than sizeof(void*), the value will be
+ dynamically allocated in a separate chunk of memory.
+
+ In either case, the data is stored in a binary compatible format to LV2_Atom
+ (i.e., if the value is dynamically allocated, the header is repeated there).
+
+ @ingroup raul
+*/
+class Atom {
+public:
+ Atom() { _atom.size = 0; _atom.type = 0; _body.ptr = NULL; }
+ ~Atom() { dealloc(); }
+
+ /** Contruct a raw atom.
+ *
+ * Typically this is not used directly, use Forge methods to make atoms.
+ */
+ Atom(uint32_t size, LV2_URID type, const void* body) {
+ _atom.size = size;
+ _atom.type = type;
+ _body.ptr = NULL;
+ if (is_reference()) {
+ _body.ptr = (LV2_Atom*)malloc(sizeof(LV2_Atom) + size);
+ memcpy(_body.ptr, &_atom, sizeof(LV2_Atom));
+ }
+ if (body) {
+ memcpy(get_body(), body, size);
+ }
+ }
+
+ Atom(const Atom& copy)
+ : _atom(copy._atom)
+ {
+ if (is_reference()) {
+ _body.ptr = (LV2_Atom*)malloc(sizeof(LV2_Atom) + _atom.size);
+ memcpy(_body.ptr, copy._body.ptr, sizeof(LV2_Atom) + _atom.size);
+ } else {
+ memcpy(&_body.val, &copy._body.val, sizeof(LV2_Atom));
+ }
+ }
+
+ Atom& operator=(const Atom& other) {
+ if (&other == this) {
+ return *this;
+ }
+ dealloc();
+ _atom = other._atom;
+ if (is_reference()) {
+ _body.ptr = (LV2_Atom*)malloc(sizeof(LV2_Atom) + _atom.size);
+ memcpy(_body.ptr, other._body.ptr, sizeof(LV2_Atom) + _atom.size);
+ } else {
+ memcpy(&_body.val, &other._body.val, sizeof(LV2_Atom));
+ }
+ return *this;
+ }
+
+ inline bool operator==(const Atom& other) const {
+ if (is_reference()) {
+ return !memcmp(_body.ptr, other._body.ptr, sizeof(LV2_Atom) + _atom.size);
+ }
+ return (_atom.type == other._atom.type &&
+ _atom.size == other._atom.size &&
+ _body.val == other._body.val);
+ }
+
+ inline bool operator!=(const Atom& other) const {
+ return !operator==(other);
+ }
+
+ inline bool operator<(const Atom& other) const {
+ if (_atom.type == other._atom.type) {
+ if (is_reference()) {
+ return memcmp(_body.ptr, other._body.ptr, _atom.size) < 0;
+ } else {
+ return memcmp(&_body.val, &other._body.val, _atom.size) < 0;
+ }
+ }
+ return type() < other.type();
+ }
+
+ inline uint32_t size() const { return _atom.size; }
+ inline LV2_URID type() const { return _atom.type; }
+ inline bool is_valid() const { return _atom.type; }
+
+ inline const void* get_body() const {
+ return is_reference() ? (void*)(_body.ptr + 1) : &_body.val;
+ }
+
+ inline void* get_body() {
+ return is_reference() ? (void*)(_body.ptr + 1) : &_body.val;
+ }
+
+ template <typename T> const T& get() const {
+ assert(size() == sizeof(T));
+ return *static_cast<const T*>(get_body());
+ }
+
+ template <typename T> const T* ptr() const {
+ return static_cast<const T*>(get_body());
+ }
+
+ const LV2_Atom* atom() const {
+ return is_reference() ? _body.ptr : &_atom;
+ }
+
+private:
+ friend class Forge;
+
+ /** Free dynamically allocated value, if applicable. */
+ inline void dealloc() {
+ if (is_reference()) {
+ free(_body.ptr);
+ }
+ }
+
+ /** Return true iff this value is dynamically allocated. */
+ inline bool is_reference() const {
+ return _atom.size > sizeof(_body.val);
+ }
+
+ LV2_Atom _atom;
+ union {
+ intptr_t val;
+ LV2_Atom* ptr;
+ } _body;
+};
+
+} // namespace Ingen
+
+#endif // INGEN_ATOM_HPP