Relintai/sfw
1
0
Fork 0
mirror of https://github.com/Relintai/sfw.git synced 2024-11-15 00:06:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

Removed my old variant.

Browse Source
This commit is contained in:
Relintai 2023-12-31 20:01:25 +01:00
parent f48208c855
commit eb5d27a51e
2 changed files with 0 additions and 744 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

624
sfw/object/old/variant.cpp
View File

@ -1,624 +0,0 @@
#include "variant.h"
#include "math.h"
#include "core/reference.h"
Variant::Type Variant::get_type() const {
return _type;
}
void Variant::clear() {
switch (_type) {
case TYPE_NULL:
break;
case TYPE_BOOL:
_bool = false;
break;
case TYPE_INT:
_int = 0;
break;
case TYPE_UINT:
_uint = 0;
break;
case TYPE_FLOAT:
_float = 0;
break;
case TYPE_STRING:
if (_string->owner) {
delete _string->string;
}
delete _string;
_string = nullptr;
break;
case TYPE_OBJECT:
delete _object;
_object = nullptr;
break;
case TYPE_POINTER:
_pointer = nullptr;
break;
default:
break;
}
_type = TYPE_NULL;
}
void Variant::zero() {
switch (_type) {
case TYPE_NULL:
break;
case TYPE_BOOL:
_bool = false;
break;
case TYPE_INT:
_int = 0;
break;
case TYPE_UINT:
_uint = 0;
break;
case TYPE_FLOAT:
_float = 0;
break;
case TYPE_STRING:
_string->string->resize(0);
break;
case TYPE_OBJECT:
_object->object = nullptr;
_object->reference.unref();
break;
case TYPE_POINTER:
_pointer = nullptr;
break;
default:
break;
}
}
void Variant::parse(const String &str) {
if (str.is_int()) {
set_int(str.to_int());
return;
}
if (str.is_uint()) {
set_uint(str.to_uint());
return;
}
if (str.is_numeric()) {
set_float(str.to_float());
return;
}
if (str.is_bool()) {
set_bool(str.to_bool());
return;
}
set_string(str);
}
Variant Variant::parse_string(const String &str) {
Variant v = Variant();
v.parse(str);
return v;
}
bool Variant::is_null() const {
return _type == TYPE_NULL;
}
bool Variant::is_bool() const {
return _type == TYPE_BOOL;
}
bool Variant::is_int() const {
return _type == TYPE_INT;
}
bool Variant::is_uint() const {
return _type == TYPE_UINT;
}
bool Variant::is_float() const {
return _type == TYPE_FLOAT;
}
bool Variant::is_numeric() const {
return _type == TYPE_INT || _type == TYPE_UINT || _type == TYPE_FLOAT;
}
bool Variant::is_string() const {
return _type == TYPE_STRING;
}
bool Variant::is_object() const {
return _type == TYPE_OBJECT;
}
bool Variant::is_pointer() const {
return _type == TYPE_POINTER;
}
bool Variant::is_reference() const {
if (_type == TYPE_OBJECT) {
return _object->reference.is_valid();
}
return false;
}
bool Variant::is_primitive_type() const {
return _type == TYPE_BOOL || _type == TYPE_INT || _type == TYPE_UINT || _type == TYPE_FLOAT;
}
bool Variant::is_simple_type() const {
return _type == TYPE_BOOL || _type == TYPE_INT || _type == TYPE_UINT || _type == TYPE_FLOAT || _type == TYPE_STRING;
}
bool Variant::to_bool() const {
return _bool;
}
int Variant::to_int() const {
switch (_type) {
case TYPE_NULL:
return 0;
case TYPE_BOOL:
if (_bool) {
return 1;
} else {
return 0;
}
case TYPE_INT:
case TYPE_UINT:
return _int;
case TYPE_FLOAT:
return static_cast<float>(_int);
case TYPE_STRING:
return _string->string->to_int();
case TYPE_OBJECT:
case TYPE_POINTER:
// just read the value of the pointer as int
// Could return 1 or 0, but this is almost the same, but hopefully it's more useful
return _int;
default:
return 0;
}
}
uint64_t Variant::to_uint() const {
switch (_type) {
case TYPE_NULL:
return 0;
case TYPE_BOOL:
if (_bool) {
return 1;
} else {
return 0;
}
case TYPE_INT:
case TYPE_UINT:
return _uint;
case TYPE_FLOAT:
return static_cast<uint64_t>(_float);
case TYPE_STRING:
return _string->string->to_uint();
case TYPE_OBJECT:
case TYPE_POINTER:
// just read the value of the pointer as uint
// Could return 1 or 0, but this is almost the same, but hopefully it's more useful
return _uint;
default:
return 0;
}
}
float Variant::to_float() const {
switch (_type) {
case TYPE_NULL:
return 0;
case TYPE_BOOL:
if (_bool) {
return 0;
} else {
return 1;
}
case TYPE_INT:
return static_cast<float>(_int);
case TYPE_UINT:
return static_cast<float>(_uint);
case TYPE_FLOAT:
return _float;
case TYPE_STRING:
return _string->string->to_float();
case TYPE_OBJECT:
case TYPE_POINTER:
if (_uint) {
return 1;
} else {
return 0;
}
default:
return 0;
}
}
String Variant::to_string() const {
switch (_type) {
case TYPE_NULL:
return "NULL";
case TYPE_BOOL:
if (Math::is_zero_approx(_float)) {
return "false";
} else {
return "true";
}
case TYPE_INT:
return String::num(_int);
case TYPE_UINT:
return String::num(_uint);
case TYPE_FLOAT:
return String::num(_float);
case TYPE_STRING:
return *(_string->string);
case TYPE_OBJECT:
case TYPE_POINTER:
if (_uint) {
return "[ Object ]";
} else {
return "[ Object (NULL) ]";
}
default:
return "";
}
}
Object *Variant::to_object() const {
switch (_type) {
case TYPE_NULL:
return nullptr;
case TYPE_BOOL:
return nullptr;
case TYPE_INT:
return nullptr;
case TYPE_UINT:
return nullptr;
case TYPE_FLOAT:
return nullptr;
case TYPE_STRING:
return nullptr;
case TYPE_OBJECT:
return _object->object;
case TYPE_POINTER:
return nullptr;
default:
return nullptr;
}
}
Reference *Variant::to_reference() const {
switch (_type) {
case TYPE_NULL:
return nullptr;
case TYPE_BOOL:
return nullptr;
case TYPE_INT:
return nullptr;
case TYPE_UINT:
return nullptr;
case TYPE_FLOAT:
return nullptr;
case TYPE_STRING:
return nullptr;
case TYPE_OBJECT:
return Object::cast_to<Reference>(_object->object);
case TYPE_POINTER:
return nullptr;
default:
return nullptr;
}
}
void *Variant::to_pointer() const {
switch (_type) {
case TYPE_NULL:
return nullptr;
case TYPE_BOOL:
return nullptr;
case TYPE_INT:
return nullptr;
case TYPE_UINT:
return nullptr;
case TYPE_FLOAT:
return nullptr;
case TYPE_STRING:
return nullptr;
case TYPE_OBJECT:
return nullptr;
case TYPE_POINTER:
return _pointer;
default:
return nullptr;
}
}
String *Variant::get_string_ptr() const {
if (_type == TYPE_STRING) {
return _string->string;
}
return nullptr;
}
bool Variant::is_string_owned() const {
if (_type == TYPE_STRING) {
return _string->owner;
}
return false;
}
void Variant::set_null() {
clear();
_type = TYPE_NULL;
}
void Variant::set_bool(const bool value) {
clear();
_type = TYPE_BOOL;
_bool = value;
}
void Variant::set_int(const int value) {
clear();
_type = TYPE_INT;
_int = value;
}
void Variant::set_uint(const uint64_t value) {
clear();
_type = TYPE_UINT;
_uint = value;
}
void Variant::set_float(const float value) {
clear();
_type = TYPE_FLOAT;
_float = value;
}
void Variant::set_float(const double value) {
clear();
_type = TYPE_FLOAT;
_float = value;
}
void Variant::set_string(String *value, const bool copy) {
clear();
if (!value) {
return;
}
_type = TYPE_STRING;
_string = new StringData();
if (copy) {
_string->string = new String(*value);
_string->owner = true;
} else {
_string->string = value;
_string->owner = false;
}
}
void Variant::set_string(const String &value, const bool copy) {
clear();
_type = TYPE_STRING;
_string = new StringData();
if (copy) {
_string->string = new String(value);
_string->owner = true;
} else {
_string->string = &const_cast<String &>(value);
_string->owner = false;
}
}
void Variant::set_object(Object *value) {
clear();
if (!value) {
return;
}
_object = new ObjectData();
_object->object = value;
if (value->is_class_ptr(Reference::get_class_ptr_static())) {
_object->reference = Ref<Reference>(Object::cast_to<Reference>(value));
}
}
void Variant::set_pointer(void *value) {
clear();
_type = TYPE_POINTER;
_pointer = value;
}
void Variant::set_variant(const Variant &value) {
clear();
switch (value._type) {
case TYPE_NULL:
break;
case TYPE_BOOL:
_bool = value._bool;
break;
case TYPE_INT:
_int = value._int;
break;
case TYPE_UINT:
_uint = value._uint;
break;
case TYPE_FLOAT:
_float = value._float;
break;
case TYPE_STRING:
set_string(value._string->string, true);
break;
case TYPE_OBJECT:
set_object(value._object->object);
break;
case TYPE_POINTER:
_pointer = value._pointer;
default:
break;
}
_type = value._type;
}
Variant::operator bool() const {
return to_bool();
}
Variant::operator int() const {
return to_int();
}
Variant::operator uint64_t() const {
return to_uint();
}
Variant::operator float() const {
return to_float();
}
Variant::operator double() const {
return to_float();
}
Variant::operator String() const {
return to_string();
}
Variant::operator Object *() const {
return to_object();
}
Variant::operator Reference *() const {
return to_reference();
}
Variant::operator void *() const {
return to_pointer();
}
void Variant::operator=(const Variant &other) {
set_variant(other);
}
bool Variant::operator==(const Variant &other) const {
if (_type != other._type) {
return false;
}
switch (_type) {
case TYPE_NULL:
return true;
case TYPE_BOOL:
return _bool == other._bool;
case TYPE_INT:
return _int == other._int;
case TYPE_UINT:
return _uint == other._uint;
case TYPE_FLOAT:
return _float == other._float;
case TYPE_STRING:
return (*_string->string) == (*other._string->string);
case TYPE_OBJECT:
return (_object->object) == (other._object->object);
case TYPE_POINTER:
return _pointer == other._pointer;
default:
break;
}
return false;
}
bool Variant::operator!=(const Variant &other) const {
return !(operator==(other));
}
bool Variant::operator<(const Variant &other) const {
switch (_type) {
case TYPE_NULL: {
if (other.is_null()) {
return false;
} else {
return true;
}
}
case TYPE_BOOL: {
return _bool < other.to_bool();
}
case TYPE_INT:
return _int < other.to_int();
return _int == other._int;
case TYPE_UINT:
return _uint < other.to_uint();
return _uint == other._uint;
case TYPE_FLOAT:
return _float < other.to_float();
return _float == other._float;
case TYPE_STRING:
return (*_string->string) < other.to_string();
case TYPE_OBJECT:
return (_object->object) < other.to_object();
case TYPE_POINTER:
return _pointer < other.to_pointer();
default:
break;
}
return false;
}
Variant::Variant(const bool value) {
_type = TYPE_BOOL;
_bool = value;
}
Variant::Variant(const int value) {
_type = TYPE_INT;
_int = value;
}
Variant::Variant(const uint64_t value) {
_type = TYPE_UINT;
_uint = value;
}
Variant::Variant(const float value) {
_type = TYPE_FLOAT;
_float = value;
}
Variant::Variant(const double value) {
_type = TYPE_FLOAT;
_float = value;
}
Variant::Variant(String *value, bool copy) {
_type = TYPE_NULL;
set_string(value, copy);
}
Variant::Variant(const String &value, bool copy) {
_type = TYPE_NULL;
set_string(value, copy);
}
Variant::Variant(Object *value) {
_type = TYPE_NULL;
set_object(value);
}
Variant::Variant(void *value) {
_type = TYPE_NULL;
set_pointer(value);
}
Variant::Variant(const Variant &value) {
_type = TYPE_NULL;
set_variant(value);
}
Variant::Variant() {
_type = TYPE_NULL;
}
Variant::~Variant() {
clear();
}

120
sfw/object/old/variant.h
View File

@ -1,120 +0,0 @@
#ifndef VARIANT_H
#define VARIANT_H
#include "core/object.h"
#include "core/reference.h"
#include "core/string.h"
class Variant {
public:
enum Type {
TYPE_NULL = 0,
TYPE_BOOL,
TYPE_INT,
TYPE_UINT,
TYPE_FLOAT,
TYPE_STRING,
TYPE_OBJECT,
TYPE_POINTER,
};
Type get_type() const;
void clear();
void zero();
void parse(const String &str);
static Variant parse_string(const String &str);
bool is_null() const;
bool is_bool() const;
bool is_int() const;
bool is_uint() const;
bool is_float() const;
bool is_numeric() const;
bool is_string() const;
bool is_object() const;
bool is_pointer() const;
bool is_reference() const;
bool is_primitive_type() const;
bool is_simple_type() const;
bool to_bool() const;
int to_int() const;
uint64_t to_uint() const;
float to_float() const;
String to_string() const;
Object *to_object() const;
Reference *to_reference() const;
void *to_pointer() const;
String *get_string_ptr() const;
bool is_string_owned() const;
void set_null();
void set_bool(const bool value);
void set_int(const int value);
void set_uint(const uint64_t value);
void set_float(const float value);
void set_float(const double value);
void set_string(String *value, bool copy = false);
void set_string(const String &value, bool copy = true);
void set_object(Object *value);
void set_pointer(void *value);
void set_variant(const Variant &value);
operator bool() const;
operator int() const;
operator uint64_t() const;
operator float() const;
operator double() const;
operator String() const;
operator Object *() const;
operator Reference *() const;
operator void *() const;
void operator=(const Variant &other);
bool operator==(const Variant &other) const;
bool operator!=(const Variant &other) const;
bool operator<(const Variant &other) const;
Variant(const bool value);
Variant(const int value);
Variant(const uint64_t value);
Variant(const float value);
Variant(const double value);
Variant(String *value, const bool copy = false);
Variant(const String &value, const bool copy = true);
Variant(Object *value);
Variant(void *value);
Variant(const Variant &value);
Variant();
~Variant();
private:
struct StringData {
bool owner;
String *string;
};
struct ObjectData {
Object *object;
Ref<Reference> reference;
};
union {
bool _bool;
int _int;
uint64_t _uint;
float _float;
StringData *_string;
ObjectData *_object;
void *_pointer;
};
Type _type;
};
#endif