added Function, Property and Object classes; added CMakeLists entries for the mozjs-24 library (the Firefox JavaScript engine which is available as Package on Fedora); added Doxygen target to makefile

git-svn-id: file:///var/local/svn/basicwriter@75 daaaf23c-2e50-4459-9457-1e69db5a47bf

1 files changed, 243 insertions, 11 deletions

diff --git a/src/core/script/Variant.cpp b/src/core/script/Variant.cpp
index 3858b68..75f46ba 100644
--- a/src/core/script/Variant.cpp
+++ b/src/core/script/Variant.cpp
@@ -17,13 +17,242 @@
 */
 
 #include "Variant.hpp"
+#include "Function.hpp"
+#include "Object.hpp"
 
 namespace ousia {
 namespace script {
 
-/* Class VariantTypeException */
+/* Class Variant */
+
+Variant::Variant(const Variant &v) : type(v.type)
+{
+	switch (v.type) {
+		case VariantType::null:
+			break;
+		case VariantType::boolean:
+			booleanValue = v.booleanValue;
+			break;
+		case VariantType::integer:
+			integerValue = v.integerValue;
+			break;
+		case VariantType::number:
+			numberValue = v.numberValue;
+			break;
+		case VariantType::string:
+			objectValue =
+			    new std::string(*static_cast<std::string *>(v.objectValue));
+			break;
+		case VariantType::array:
+			objectValue = new std::vector<Variant>(
+			    *static_cast<std::vector<Variant> *>(v.objectValue));
+			break;
+		case VariantType::map:
+			objectValue = new std::map<std::string, Variant>(
+			    *static_cast<std::map<std::string, Variant> *>(v.objectValue));
+			break;
+		case VariantType::function:
+			objectValue = static_cast<Function *>(v.objectValue)->clone();
+			break;
+		case VariantType::object:
+			objectValue = new Object(*static_cast<Object *>(v.objectValue));
+			break;
+		case VariantType::buffer:
+			// TODO
+			break;
+	}
+}
+
+Variant::Variant(Variant &&v) : type(v.type)
+{
+	switch (type) {
+		case VariantType::null:
+			break;
+		case VariantType::boolean:
+			booleanValue = v.booleanValue;
+			break;
+		case VariantType::integer:
+			integerValue = v.integerValue;
+			break;
+		case VariantType::number:
+			numberValue = v.numberValue;
+			break;
+		case VariantType::string:
+		case VariantType::array:
+		case VariantType::map:
+		case VariantType::function:
+		case VariantType::object:
+		case VariantType::buffer:
+			objectValue = v.objectValue;
+			v.objectValue = nullptr;
+			break;
+	}
+}
+
+Variant::Variant() : type(VariantType::null)
+{
+}
+
+Variant::Variant(bool b) : type(VariantType::boolean), booleanValue(b)
+{
+}
+
+Variant::Variant(int64_t i) : type(VariantType::integer), integerValue(i)
+{
+}
+
+Variant::Variant(double d) : type(VariantType::number), numberValue(d)
+{
+}
+
+Variant::Variant(const char *s)
+    : type(VariantType::string), objectValue(new std::string(s))
+{
+}
+
+Variant::Variant(const std::vector<Variant> &a)
+    : type(VariantType::array), objectValue(new std::vector<Variant>(a))
+{
+}
+
+Variant::Variant(const std::map<std::string, Variant> &m)
+    : type(VariantType::map), objectValue(new std::map<std::string, Variant>(m))
+{
+}
+
+Variant::Variant(const Function *f)
+    : type(VariantType::function), objectValue(f->clone())
+{
+}
+
+Variant::Variant(const Object &o)
+    : type(VariantType::object), objectValue(new Object(o))
+{
+}
+
+Variant::~Variant()
+{
+	switch (type) {
+		case VariantType::string:
+			delete static_cast<std::string *>(objectValue);
+			break;
+		case VariantType::array:
+			delete static_cast<std::vector<Variant> *>(objectValue);
+			break;
+		case VariantType::map:
+			delete static_cast<std::map<std::string, Variant> *>(objectValue);
+			break;
+		case VariantType::function:
+			delete static_cast<Function*>(objectValue);
+			break;
+		case VariantType::object:
+			delete static_cast<Object*>(objectValue);
+			break;
+		default:
+			break;
+	}
+}
 
-const char* Variant::getTypeName(VariantType type)
+bool Variant::getBooleanValue() const
+{
+	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 VariantTypeException{type, VariantType::boolean};
+	}
+}
+
+int64_t Variant::getIntegerValue() const
+{
+	switch (type) {
+		case VariantType::boolean:
+			return booleanValue ? 1 : 0;
+		case VariantType::integer:
+			return integerValue;
+		case VariantType::number:
+			return static_cast<int64_t>(numberValue);
+		default:
+			throw VariantTypeException{type, VariantType::integer};
+	}
+}
+
+double Variant::getNumberValue() const
+{
+	switch (type) {
+		case VariantType::boolean:
+			return booleanValue ? 1.0 : 0.0;
+		case VariantType::integer:
+			return static_cast<double>(integerValue);
+		case VariantType::number:
+			return numberValue;
+		default:
+			throw VariantTypeException{type, VariantType::number};
+	}
+}
+
+const std::string &Variant::getStringValue() const
+{
+	switch (type) {
+		case VariantType::string:
+			return *(static_cast<std::string *>(objectValue));
+		default:
+			throw VariantTypeException{type, VariantType::string};
+	}
+}
+
+const std::vector<Variant> &Variant::getArrayValue() const
+{
+	switch (type) {
+		case VariantType::array:
+			return *(static_cast<std::vector<Variant> *>(objectValue));
+		default:
+			throw VariantTypeException{type, VariantType::array};
+	}
+}
+
+const std::map<std::string, Variant> &Variant::getMapValue() const
+{
+	switch (type) {
+		case VariantType::map:
+			return *(static_cast<std::map<std::string, Variant> *>(
+			    objectValue));
+		default:
+			throw VariantTypeException{type, VariantType::map};
+	}
+}
+
+const Function *Variant::getFunctionValue() const
+{
+	switch (type) {
+		case VariantType::function: return static_cast<Function *>(objectValue);
+		    default:
+			throw VariantTypeException{type, VariantType::function};
+	}
+}
+
+const Object &Variant::getObjectValue() const
+{
+	switch (type) {
+		case VariantType::object: return *(static_cast<Object *>(objectValue));
+		    default:
+			throw VariantTypeException{type, VariantType::function};
+	}
+}
+
+const char *Variant::getTypeName(VariantType type)
 {
 	switch (type) {
 		case VariantType::null:
@@ -50,22 +279,26 @@ const char* Variant::getTypeName(VariantType type)
 	return "unknown";
 }
 
+/* Class VariantTypeException */
+
 VariantTypeException::VariantTypeException(VariantType actualType,
-		VariantType requestedType) :
-	msg(std::string("Cannot get value of variant of type \"")
-			+ Variant::getTypeName(actualType)
-			+ std::string("\" as \"") + Variant::getTypeName(requestedType)
-			+ std::string("\"")),
-	actualType(actualType), requestedType(requestedType) {}
+                                           VariantType requestedType)
+    : msg(std::string("Cannot get value of variant of type \"") +
+          Variant::getTypeName(actualType) + std::string("\" as \"") +
+          Variant::getTypeName(requestedType) + std::string("\"")),
+      actualType(actualType),
+      requestedType(requestedType)
+{
+}
 
-const char* VariantTypeException::what() const noexcept
+const char *VariantTypeException::what() const noexcept
 {
 	return msg.c_str();
 }
 
 /* Global scope operator */
 
-std::ostream& operator<< (std::ostream& os, const Variant &v)
+std::ostream &operator<<(std::ostream &os, const Variant &v)
 {
 	switch (v.type) {
 		case VariantType::null:
@@ -121,7 +354,6 @@ std::ostream& operator<< (std::ostream& os, const Variant &v)
 	}
 	return os;
 }
-
 }
 }