aboutsummaryrefslogtreecommitdiff
path: root/engines/zvision
diff options
context:
space:
mode:
Diffstat (limited to 'engines/zvision')
-rw-r--r--engines/zvision/object.cpp371
-rw-r--r--engines/zvision/object.h121
2 files changed, 492 insertions, 0 deletions
diff --git a/engines/zvision/object.cpp b/engines/zvision/object.cpp
new file mode 100644
index 0000000000..253eaf7ace
--- /dev/null
+++ b/engines/zvision/object.cpp
@@ -0,0 +1,371 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/textconsole.h"
+
+#include "zvision/object.h"
+
+namespace ZVision {
+
+Object::Object(ObjectType type) {
+ _objectType = type;
+
+ switch (type) {
+ case BOOL:
+ _value.boolVal = new bool;
+ break;
+ case BYTE:
+ _value.byteVal = new byte;
+ break;
+ case INT16:
+ _value.int16Val = new int16;
+ break;
+ case UINT16:
+ _value.uint16Val = new uint16;
+ break;
+ case INT32:
+ _value.int32Val = new int32;
+ break;
+ case UINT32:
+ _value.uint32Val = new uint32;
+ break;
+ case FLOAT:
+ _value.floatVal = new float;
+ break;
+ case DOUBLE:
+ _value.doubleVal = new double;
+ break;
+ case STRING:
+ _value.stringVal = new Common::String;
+ break;
+ }
+}
+
+Object::Object(bool value) : _objectType(BOOL) {
+ _value.boolVal = new bool(value);
+}
+
+Object::Object(byte value) : _objectType(BYTE) {
+ _value.byteVal = new byte(value);
+}
+
+Object::Object(int16 value) : _objectType(INT16) {
+ _value.int16Val = new int16(value);
+}
+
+Object::Object(uint16 value) : _objectType(UINT16) {
+ _value.uint16Val = new uint16(value);
+}
+
+Object::Object(int32 value) : _objectType(INT32) {
+ _value.int32Val = new int32(value);
+}
+
+Object::Object(uint32 value) : _objectType(UINT32) {
+ _value.uint32Val = new uint32(value);
+}
+
+Object::Object(float value) : _objectType(FLOAT) {
+ _value.floatVal = new float(value);
+}
+
+Object::Object(double value) : _objectType(DOUBLE) {
+ _value.doubleVal = new double(value);
+}
+
+Object::Object(Common::String value) : _objectType(BYTE) {
+ _value.stringVal = new Common::String(value);
+}
+
+Object::Object(const Object& other) {
+ _objectType = other._objectType;
+
+ switch (_objectType) {
+ case BOOL:
+ _value.boolVal = new bool(*other._value.boolVal);
+ break;
+ case BYTE:
+ _value.byteVal = new byte(*other._value.byteVal);
+ break;
+ case INT16:
+ _value.int16Val = new int16(*other._value.int16Val);
+ break;
+ case UINT16:
+ _value.uint16Val = new uint16(*other._value.uint16Val);
+ break;
+ case INT32:
+ _value.int32Val = new int32(*other._value.int32Val);
+ break;
+ case UINT32:
+ _value.uint32Val = new uint32(*other._value.uint32Val);
+ break;
+ case FLOAT:
+ _value.floatVal = new float(*other._value.floatVal);
+ break;
+ case DOUBLE:
+ _value.doubleVal = new double(*other._value.doubleVal);
+ break;
+ case STRING:
+ _value.stringVal = new Common::String(*other._value.stringVal);
+ break;
+ }
+}
+
+Object::~Object() {
+ deleteValue();
+}
+
+void Object::deleteValue() {
+ // Call delete on the correct part of the union.
+ // Even though they all point to the same memory and will all be cast
+ // to a void *, compiler optimizations could cause undefined behavior.
+ switch (_objectType) {
+ case BOOL:
+ delete _value.boolVal;
+ break;
+ case BYTE:
+ delete _value.byteVal;
+ break;
+ case INT16:
+ delete _value.int16Val;
+ break;
+ case UINT16:
+ delete _value.uint16Val;
+ break;
+ case INT32:
+ delete _value.int32Val;
+ break;
+ case UINT32:
+ delete _value.uint32Val;
+ break;
+ case FLOAT:
+ delete _value.floatVal;
+ break;
+ case DOUBLE:
+ delete _value.doubleVal;
+ break;
+ case STRING:
+ delete _value.stringVal;
+ break;
+ }
+}
+
+
+Object& Object::operator=(const bool& rhs) {
+ if (_objectType == BOOL)
+ *_value.boolVal = rhs;
+ else {
+ deleteValue();
+ _objectType = BOOL;
+ _value.boolVal = new bool(rhs);
+ }
+
+ return *this;
+}
+
+Object& Object::operator=(const byte& rhs) {
+ if (_objectType == BYTE)
+ *_value.byteVal = rhs;
+ else {
+ deleteValue();
+ _objectType = BYTE;
+ _value.byteVal = new byte(rhs);
+ }
+
+ return *this;
+}
+
+Object& Object::operator=(const int16& rhs) {
+ if (_objectType == INT16)
+ *_value.int16Val = rhs;
+ else {
+ deleteValue();
+ _objectType = INT16;
+ _value.int16Val = new int16(rhs);
+ }
+
+ return *this;
+}
+
+Object& Object::operator=(const uint16& rhs) {
+ if (_objectType == UINT16)
+ *_value.uint16Val = rhs;
+ else {
+ deleteValue();
+ _objectType = UINT16;
+ _value.uint16Val = new uint16(rhs);
+ }
+
+ return *this;
+}
+
+Object& Object::operator=(const int32& rhs) {
+ if (_objectType == INT32)
+ *_value.int32Val = rhs;
+ else {
+ deleteValue();
+ _objectType = INT32;
+ _value.int32Val = new int32(rhs);
+ }
+
+ return *this;
+}
+
+Object& Object::operator=(const uint32& rhs) {
+ if (_objectType == UINT32)
+ *_value.uint32Val = rhs;
+ else {
+ deleteValue();
+ _objectType = UINT32;
+ _value.uint32Val = new uint32(rhs);
+ }
+
+ return *this;
+}
+
+Object& Object::operator=(const float& rhs) {
+ if (_objectType == FLOAT)
+ *_value.floatVal = rhs;
+ else {
+ deleteValue();
+ _objectType = FLOAT;
+ _value.floatVal = new float(rhs);
+ }
+
+ return *this;
+}
+
+Object& Object::operator=(const double& rhs) {
+ if (_objectType == DOUBLE)
+ *_value.doubleVal = rhs;
+ else {
+ deleteValue();
+ _objectType = DOUBLE;
+ _value.doubleVal = new double(rhs);
+ }
+
+ return *this;
+}
+
+Object& Object::operator=(const Common::String& rhs) {
+ if (_objectType == STRING)
+ *_value.stringVal = rhs;
+ else {
+ deleteValue();
+ _objectType = STRING;
+ _value.stringVal = new Common::String(rhs);
+ }
+
+ return *this;
+}
+
+Object& Object::operator=(const Object& rhs) {
+ switch (_objectType) {
+ case BOOL:
+ return operator=(*rhs._value.boolVal);
+ case BYTE:
+ return operator=(*rhs._value.byteVal);
+ case INT16:
+ return operator=(*rhs._value.int16Val);
+ case UINT16:
+ return operator=(*rhs._value.uint16Val);
+ case INT32:
+ return operator=(*rhs._value.int32Val);
+ case UINT32:
+ return operator=(*rhs._value.uint32Val);
+ case FLOAT:
+ return operator=(*rhs._value.floatVal);
+ case DOUBLE:
+ return operator=(*rhs._value.doubleVal);
+ case STRING:
+ return operator=(*rhs._value.stringVal);
+ }
+
+ return *this;
+}
+
+
+Object::operator bool() {
+ if (_objectType != BOOL)
+ warning("'Object' not of type bool. Bad cast");
+
+ return *_value.boolVal;
+}
+
+Object::operator byte() {
+ if (_objectType != BYTE)
+ warning("'Object' not of type byte. Bad cast");
+
+ return *_value.byteVal;
+}
+
+Object::operator int16() {
+ if (_objectType != INT16)
+ warning("'Object' not of type int16. Bad cast");
+
+ return *_value.int16Val;
+}
+
+Object::operator uint16() {
+ if (_objectType != UINT16)
+ warning("'Object' not of type uint16. Bad cast");
+
+ return *_value.uint16Val;
+}
+
+Object::operator int32() {
+ if (_objectType != INT32)
+ warning("'Object' not of type int32. Bad cast");
+
+ return *_value.int32Val;
+}
+
+Object::operator uint32() {
+ if (_objectType != UINT32)
+ warning("'Object' not of type uint32. Bad cast");
+
+ return *_value.uint32Val;
+}
+
+Object::operator float() {
+ if (_objectType != FLOAT)
+ warning("'Object' not of type float. Bad cast");
+
+ return *_value.floatVal;
+}
+
+Object::operator double() {
+ if (_objectType != DOUBLE)
+ warning("'Object' not of type double. Bad cast");
+
+ return *_value.doubleVal;
+}
+
+Object::operator Common::String() {
+ if (_objectType != STRING)
+ warning("'Object' not of type Common::String. Bad cast");
+
+ return *_value.stringVal;
+}
+
+} // End namespace ZVision
diff --git a/engines/zvision/object.h b/engines/zvision/object.h
new file mode 100644
index 0000000000..02ca962239
--- /dev/null
+++ b/engines/zvision/object.h
@@ -0,0 +1,121 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef ZVISION_OBJECT_H
+#define ZVISION_OBJECT_H
+
+#include "common/str.h"
+
+namespace ZVision {
+
+
+enum ObjectType {
+ BOOL,
+ BYTE,
+ INT16,
+ UINT16,
+ INT32,
+ UINT32,
+ FLOAT,
+ DOUBLE,
+ STRING,
+};
+
+/**
+ * A generic single value storage class. It is useful for storing different
+ * value types in a single List, Hashmap, etc.
+ *
+ * Mimics C#'s Object class
+ *
+ * Caution: The actual value is stored on the heap, so be careful creating
+ * many objects of this class. Also, when re-using 'Object', try to assign
+ * a value of the same type as before, as this will prevent an extra memory allocation.
+ */
+class Object {
+public:
+ // Constructors
+ Object(ObjectType type);
+ Object(bool value);
+ Object(byte value);
+ Object(int16 value);
+ Object(uint16 value);
+ Object(int32 value);
+ Object(uint32 value);
+ Object(float value);
+ Object(double value);
+ Object(Common::String value);
+
+ // Copy constructor
+ Object(const Object& other);
+
+ // Destructor
+ ~Object();
+
+private:
+ ObjectType _objectType;
+
+ union {
+ bool *boolVal;
+ byte *byteVal;
+ int16 *int16Val;
+ uint16 *uint16Val;
+ int32 *int32Val;
+ uint32 *uint32Val;
+ float *floatVal;
+ double *doubleVal;
+ Common::String *stringVal;
+ } _value;
+
+public:
+ Object& operator=(const bool& rhs);
+ Object& operator=(const byte& rhs);
+ Object& operator=(const int16& rhs);
+ Object& operator=(const uint16& rhs);
+ Object& operator=(const int32& rhs);
+ Object& operator=(const uint32& rhs);
+ Object& operator=(const float& rhs);
+ Object& operator=(const double& rhs);
+ Object& operator=(const Common::String& rhs);
+
+ Object& operator=(const Object& rhs);
+
+ operator bool();
+ operator byte();
+ operator int16();
+ operator uint16();
+ operator int32();
+ operator uint32();
+ operator float();
+ operator double();
+ operator Common::String();
+
+private:
+ /**
+ * Helper method for destruction and assignment. Calls delete on
+ * the currently used data pointer
+ */
+ void deleteValue();
+};
+
+} // End namespace ZVision
+
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-16 15:37:49 +0000