From 25fb41044ca080b794cbf4e85ff10e74e571ea24 Mon Sep 17 00:00:00 2001 From: Andreas Stöckel Date: Sat, 18 Oct 2014 00:56:14 +0000 Subject: improved Variant.cpp, added ScriptEngine.hpp containing the script engine abstraction layer git-svn-id: file:///var/local/svn/basicwriter@72 daaaf23c-2e50-4459-9457-1e69db5a47bf --- src/core/script/Variant.hpp | 199 ++++++++++++++++++++------------------------ 1 file changed, 92 insertions(+), 107 deletions(-) (limited to 'src/core/script/Variant.hpp') diff --git a/src/core/script/Variant.hpp b/src/core/script/Variant.hpp index e427af5..faa5bad 100644 --- a/src/core/script/Variant.hpp +++ b/src/core/script/Variant.hpp @@ -19,6 +19,8 @@ #ifndef _OUSIA_VARIANT_HPP_ #define _OUSIA_VARIANT_HPP_ +#include + #include #include #include @@ -28,8 +30,6 @@ namespace ousia { namespace script { -// TODO: Make Variant immutable (?), store large objects in heap buffer - /** * Enum containing the possible types a variant may have. */ @@ -44,50 +44,28 @@ enum class VariantType { class Variant { private: - VariantType type; + const VariantType type; union { bool booleanValue; int64_t integerValue; double numberValue; - std::string stringValue; - std::vector arrayValue; - std::map mapValue; + void *objectValue = nullptr; }; - /** - * Private function calling the destructor of the currently used union - * member. - */ - void free() { - // Explicitly call the destructor - switch (type) { - case VariantType::string: - stringValue.std::string::~string(); - break; - case VariantType::array: - arrayValue.std::vector::~vector(); - break; - case VariantType::map: - mapValue.std::map::~map(); - break; - default: - break; - } +public: - // Reset the type - type = VariantType::none; - } + class EBadEntry {}; - /** - * Function for copying the content of the given instance v to this - * instance. Callers must make sure the storage space has been freed - * beforehand. - */ - void copy(const Variant &v) + Variant(const Variant &v) : + type(v.type) { - type = v.type; - switch (type) { + switch (v.type) { + case VariantType::null: + break; + case VariantType::boolean: + booleanValue = v.booleanValue; + break; case VariantType::integer: integerValue = v.integerValue; break; @@ -95,28 +73,34 @@ private: numberValue = v.numberValue; break; case VariantType::string: - new (&stringValue) std::string(v.stringValue); + objectValue = new std::string( + *static_cast(v.objectValue)); break; case VariantType::array: - new (&arrayValue) std::vector(v.arrayValue); + objectValue = new std::vector( + *static_cast*>(v.objectValue)); break; case VariantType::map: - new (&mapValue) std::map(v.mapValue); + objectValue = new std::map( + *static_cast*>(v.objectValue)); break; - default: + case VariantType::function: + case VariantType::object: + case VariantType::buffer: + // TODO break; } } - /** - * Function for moving the content of the given instance v to this instance. - * No copy operation is used. Callers must make sure the storage space has - * been freed beforehand. - */ - void move(Variant &v) + Variant(Variant &&v) : + type(v.type) { - type = v.type; switch (type) { + case VariantType::null: + break; + case VariantType::boolean: + booleanValue = v.booleanValue; + break; case VariantType::integer: integerValue = v.integerValue; break; @@ -124,97 +108,96 @@ private: numberValue = v.numberValue; break; case VariantType::string: - new (&stringValue) std::string(std::move(v.stringValue)); + case VariantType::array: + case VariantType::map: + case VariantType::function: + case VariantType::object: + case VariantType::buffer: + objectValue = v.objectValue; + v.objectValue = nullptr; + break; + } + } + + ~Variant() + { + switch (type) { + case VariantType::string: + delete static_cast(objectValue); break; case VariantType::array: - new (&arrayValue) std::vector(std::move(v.arrayValue)); + delete static_cast*>(objectValue); break; case VariantType::map: - new (&mapValue) std::map(std::move(v.mapValue)); + delete static_cast*>(objectValue); break; default: break; } - - // Reset the type of v to "none" - v.type = VariantType::none; } -public: + Variant& operator=(const Variant &v) = delete; + Variant& operator=(Variant &&v) = delete; - class EBadEntry {}; - - Variant(const Variant &v) - { - copy(v); - } - - Variant(Variant &&v) - { - move(v); - } - - Variant& operator=(const Variant &v) - { - free(); - copy(v); - return *this; - } - - Variant& operator=(Variant &&v) - { - free(); - move(v); - return *this; - } + Variant() : + type(VariantType::null) {} + Variant(bool b) : + type(VariantType::boolean), + booleanValue(b) {} Variant(int64_t i) : type(VariantType::integer), - integerValue(i) - { - // Do nothing here - } + integerValue(i) {} Variant(double d) : type(VariantType::number), - numberValue(d) - { - // Do nothing here - } + numberValue(d) {} Variant(const char *s) : - type(VariantType::string) - { - new (&stringValue) std::string(s); - } + type(VariantType::string), + objectValue(new std::string(s)) {} Variant(const std::vector &a) : - type(VariantType::array) - { - new (&arrayValue) std::vector(a); - } - + type(VariantType::array), + objectValue(new std::vector(a)) {} Variant(const std::map &m) : - type(VariantType::map) - { - new (&mapValue) std::map(m); - } + type(VariantType::map), + objectValue(new std::map(m)) {} - ~Variant() + VariantType getType() const { - free(); + return type; } - VariantType getType() const + bool getBooleanValue() const { - return type; + switch (type) { + case VariantType::null: + return false; + case VariantType::boolean: + return booleanValue; + case VariantType::integer: + return integerValue != 0; + case VariantType::number: + return numberValue != 0.0; + case VariantType::string: + return !getStringValue().empty(); + case VariantType::array: + return !getArrayValue().empty(); + case VariantType::map: + return !getMapValue().empty(); + default: + throw EBadEntry{}; + } } int64_t getIntegerValue() const { switch (type) { + case VariantType::boolean: + return booleanValue ? 1 : 0; case VariantType::integer: return integerValue; case VariantType::number: @@ -227,6 +210,8 @@ public: double getNumberValue() const { switch (type) { + case VariantType::boolean: + return booleanValue ? 1.0 : 0.0; case VariantType::integer: return static_cast(integerValue); case VariantType::number: @@ -240,7 +225,7 @@ public: { switch (type) { case VariantType::string: - return stringValue; + return *(static_cast(objectValue)); default: throw EBadEntry {}; } @@ -250,7 +235,7 @@ public: { switch (type) { case VariantType::array: - return arrayValue; + return *(static_cast*>(objectValue)); default: throw EBadEntry {}; } @@ -260,7 +245,7 @@ public: { switch (type) { case VariantType::map: - return mapValue; + return *(static_cast*>(objectValue)); default: throw EBadEntry {}; } -- cgit v1.2.3