removed legacy files

1 files changed, 0 insertions, 361 deletions

diff --git a/src/core/script/Variant.cpp b/src/core/script/Variant.cpp
deleted file mode 100644
index bb9f566..0000000
--- a/src/core/script/Variant.cpp
+++ /dev/null
@@ -1,361 +0,0 @@
-/*
-    Ousía
-    Copyright (C) 2014, 2015  Benjamin Paaßen, Andreas Stöckel
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program 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 General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "Variant.hpp"
-#include "Function.hpp"
-#include "Object.hpp"
-
-namespace ousia {
-namespace script {
-
-/* Class Variant */
-
-const Variant Variant::Null;
-
-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;
-	}
-}
-
-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{VariantType::boolean, type};
-	}
-}
-
-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{VariantType::integer, type};
-	}
-}
-
-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{VariantType::number, type};
-	}
-}
-
-const std::string &Variant::getStringValue() const
-{
-	switch (type) {
-		case VariantType::string:
-			return *(static_cast<std::string *>(objectValue));
-		default:
-			throw VariantTypeException{VariantType::string, type};
-	}
-}
-
-const std::vector<Variant> &Variant::getArrayValue() const
-{
-	switch (type) {
-		case VariantType::array:
-			return *(static_cast<std::vector<Variant> *>(objectValue));
-		default:
-			throw VariantTypeException{VariantType::array, type};
-	}
-}
-
-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{VariantType::map, type};
-	}
-}
-
-const Function *Variant::getFunctionValue() const
-{
-	switch (type) {
-		case VariantType::function: return static_cast<Function *>(objectValue);
-		    default:
-			throw VariantTypeException{VariantType::function, type};
-	}
-}
-
-const Object &Variant::getObjectValue() const
-{
-	switch (type) {
-		case VariantType::object: return *(static_cast<Object *>(objectValue));
-		    default:
-			throw VariantTypeException{VariantType::object, type};
-	}
-}
-
-const char *Variant::getTypeName(VariantType type)
-{
-	switch (type) {
-		case VariantType::null:
-			return "null";
-		case VariantType::boolean:
-			return "boolean";
-		case VariantType::integer:
-			return "integer";
-		case VariantType::number:
-			return "number";
-		case VariantType::string:
-			return "string";
-		case VariantType::array:
-			return "array";
-		case VariantType::map:
-			return "map";
-		case VariantType::function:
-			return "function";
-		case VariantType::object:
-			return "object";
-		case VariantType::buffer:
-			return "buffer";
-	}
-	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)
-{
-}
-
-const char *VariantTypeException::what() const noexcept
-{
-	return msg.c_str();
-}
-
-/* Global scope operator */
-
-std::ostream &operator<<(std::ostream &os, const Variant &v)
-{
-	switch (v.type) {
-		case VariantType::null:
-			os << "null";
-			break;
-		case VariantType::boolean:
-			os << (v.booleanValue ? "true" : "false");
-			break;
-		case VariantType::integer:
-			os << v.integerValue;
-			break;
-		case VariantType::number:
-			os << v.numberValue;
-			break;
-		case VariantType::string:
-			os << "\"" << v.getStringValue() << "\"";
-			break;
-		case VariantType::array: {
-			bool first = true;
-			os << "[";
-			for (auto &v2 : v.getArrayValue()) {
-				if (!first) {
-					os << ", ";
-				}
-				os << v2;
-				first = false;
-			}
-			os << "]";
-			break;
-		}
-		case VariantType::map: {
-			bool first = true;
-			os << "{";
-			for (auto &v2 : v.getMapValue()) {
-				if (!first) {
-					os << ", ";
-				}
-				os << "\"" << v2.first << "\": " << v2.second;
-				first = false;
-			}
-			os << "}";
-			break;
-		}
-		case VariantType::function:
-			os << "<Function>";
-			break;
-		case VariantType::object:
-			os << "<Object>";
-			break;
-		case VariantType::buffer:
-			os << "<Buffer>";
-			break;
-	}
-	return os;
-}
-}
-}
-