Make Atom always have an LV2_Atom so it can be used in-place.

Add missing file.


git-svn-id: http://svn.drobilla.net/lad/trunk/ingen@5080 a436a847-0d15-0410-975c-d299462d15a1

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