Objects Compiled

Objects/private/primitives/boolobject.cpp

@@ -47,12 +47,12 @@ static alni save_size(BoolObject* self) {
 	return sizeof(alni);
 }
 
-static void save(BoolObject* self, Archiver& file_self) {
-	file_self.write<alni>(&self->val);
+static void save(BoolObject* self, ArchiverOut& file_self) {
+	file_self << self->val;
 }
 
-static void load(Archiver& file_self, BoolObject* self) {
-	file_self.read<alni>(&self->val);
+static void load(ArchiverIn& file_self, BoolObject* self) {
+	file_self >> self->val;
 }
 
 struct ObjectTypeConversions BoolObjectTypeConversions = {

Objects/private/primitives/classobject.cpp

@@ -37,15 +37,15 @@ alni ClassObject::save_size(ClassObject* self) {
 	return sizeof(alni); // dict object adress
 }
 
-void ClassObject::save(ClassObject* self, Archiver& file_self) {
+void ClassObject::save(ClassObject* self, ArchiverOut& file_self) {
 	// save dictobject
 	alni ndo_object_adress = NDO->save(file_self, self->members);
-	file_self.write<alni>(&ndo_object_adress);
+	file_self << ndo_object_adress;
 }
 
-void ClassObject::load(Archiver& file_self, ClassObject* self) {
+void ClassObject::load(ArchiverIn& file_self, ClassObject* self) {
 	alni ndo_object_adress;
-	file_self.read<alni>(&ndo_object_adress);
+	file_self >> ndo_object_adress;
 	self->members = NDO_CAST(DictObject, NDO->load(file_self, ndo_object_adress));
 }
 

Objects/private/primitives/colorobject.cpp

@@ -37,12 +37,12 @@ static alni save_size(ColorObject* self) {
 	return sizeof(tp::RGBA);
 }
 
-static void save(ColorObject* self, Archiver& file_self) {
-	file_self.write<tp::RGBA>(&self->mCol);
+static void save(ColorObject* self, ArchiverOut& file_self) {
+	file_self << self->mCol;
 }
 
-static void load(Archiver& file_self, ColorObject* self) {
-	file_self.read<tp::RGBA>(&self->mCol);
+static void load(ArchiverIn& file_self, ColorObject* self) {
+	file_self >> self->mCol;
 }
 
 struct ObjectTypeConversions ColorObjectTypeConversions = {

Objects/private/primitives/dictobject.cpp

@@ -52,39 +52,39 @@ alni DictObject::save_size(DictObject* self) {
 	return save_size;
 }
 
-void DictObject::save(DictObject* self, Archiver& file_self) {
+void DictObject::save(DictObject* self, ArchiverOut& file_self) {
 
 	// write size
 	alni len = self->items.size();
-	file_self.write<alni>(&len);
+	file_self << len;
 
 	// save hashmap pairs
 	for (auto item : self->items) {
 		// item val
 		alni ndo_object_adress = NDO->save(file_self, item->val);
-		file_self.write<alni>(&ndo_object_adress);
+		file_self << ndo_object_adress;
 
 		// item key
-		item->key.save(&file_self);
+		file_self << item->key;
 	}
 }
 
-void DictObject::load(Archiver& file_self, DictObject* self) {
+void DictObject::load(ArchiverIn& file_self, DictObject* self) {
 	new (&self->items) tp::Map<tp::String, Object*>();
 
 	alni len;
-	file_self.read<alni>(&len);
+	file_self >> len;
 
 	for (alni i = 0; i < len; i++) {
 
 		// read val
 		alni ndo_object_adress;
-		file_self.read<alni>(&ndo_object_adress);
+		file_self >> ndo_object_adress;
 		Object* val = NDO->load(file_self, ndo_object_adress);
 
 		// read key value
 		String key;
-		key.load(&file_self);
+		file_self >> key;
 
 		// add to dictinary
 		self->items.put(key, val);
@@ -103,11 +103,12 @@ tp::Buffer<Object*> DictObject::childs_retrival(DictObject* self) {
 }
 
 alni DictObject::allocated_size(DictObject* self) {
-	alni out = self->items.sizeAllocatedMem();
+	ASSERT(false)
+	// alni out = self->items.sizeAllocatedMem();
 	for (auto item : self->items) {
-		out += item->key.sizeAllocatedMem();
+		// out += item->key.sizeAllocatedMem();
 	}
-	return out;
+	// return out;
 	return 0;
 }
 
@@ -141,7 +142,7 @@ tp::Map<tp::String, Object*>::Idx DictObject::presents(tp::String str) {
 	return items.presents(str);
 }
 
-Object* DictObject::getSlotVal(tp::alni idx) {
+Object* DictObject::getSlotVal(tp::Map<tp::String, Object*>::Idx idx) {
 	return items.getSlotVal(idx);
 }
 

Objects/private/primitives/enumobject.cpp

@@ -28,7 +28,7 @@ void EnumObject::copy(EnumObject* self, const EnumObject* in) {
 	tp::memCopy(self->entries, in->entries, self->nentries * ENV_ALNI_SIZE_B);
 }
 
-void obj::EnumObject::init(tp::init_list<const char*> list) {
+void obj::EnumObject::init(tp::InitialierList<const char*> list) {
 
 	if (entries) free(entries);
 
@@ -116,34 +116,34 @@ static alni save_size(EnumObject* self) {
 	return sizeof(uhalni) + sizeof(uhalni) + sizeof(alni) * self->nentries;
 }
 
-static void save(EnumObject* self, Archiver& file_self) {
+static void save(EnumObject* self, ArchiverOut& file_self) {
 	if (!self->entries) {
 		uhalni empty_code = -1;
-		file_self.write<uhalni>(&empty_code);
+		file_self << empty_code;
 		return;
 	}
-	file_self.write<uhalni>(&self->active);
-	file_self.write<uhalni>(&self->nentries);
-	file_self.write_bytes((tp::int1*) self->entries, self->nentries * ENV_ALNI_SIZE_B);
+	file_self << self->active;
+	file_self << self->nentries;
+	file_self.writeBytes((tp::int1*) self->entries, self->nentries * ENV_ALNI_SIZE_B);
 }
 
-static void load(Archiver& file_self, EnumObject* self) {
-	file_self.read<uhalni>(&self->active);
+static void load(ArchiverIn& file_self, EnumObject* self) {
+	file_self >> self->active;
 	if (self->active == -1) {
 		self->nentries = 0;
 		self->entries = NULL;
 		return;
 	}
-	file_self.read<uhalni>(&self->nentries);
+	file_self >> self->nentries;
 	self->entries = (alni*) malloc(self->nentries * ENV_ALNI_SIZE_B);
-	file_self.read_bytes((tp::int1*) self->entries, self->nentries * ENV_ALNI_SIZE_B);
+	file_self.readBytes((tp::int1*) self->entries, self->nentries * ENV_ALNI_SIZE_B);
 }
 
 bool obj::EnumObject::compare(EnumObject* first, EnumObject* second) {
 	return first->entries != NULL && second->entries != NULL && first->active == second->active;
 }
 
-EnumObject* obj::EnumObject::create(tp::init_list<const char*> list) {
+EnumObject* obj::EnumObject::create(tp::InitialierList<const char*> list) {
 	auto enum_object = (EnumObject*)obj::NDO->create("enum");
 	enum_object->init(list);
 	return enum_object;

Objects/private/primitives/floatobject.cpp

@@ -47,12 +47,12 @@ static alni save_size(FloatObject* self) {
 	return sizeof(alnf);
 }
 
-static void save(FloatObject* self, Archiver& file_self) {
-	file_self.write<alnf>(&self->val);
+static void save(FloatObject* self, ArchiverOut& file_self) {
+	file_self << self->val;
 }
 
-static void load(Archiver& file_self, FloatObject* self) {
-	file_self.read<alnf>(&self->val);
+static void load(ArchiverIn& file_self, FloatObject* self) {
+	file_self >> self->val;
 }
 
 struct ObjectTypeConversions FloatObjectTypeConversions = {

Objects/private/primitives/interpreterobject.cpp

@@ -19,13 +19,13 @@ void InterpreterObject::destructor(InterpreterObject* self) {
 	self->mInterpreter.~Interpreter();
 }
 
-void InterpreterObject::load(Archiver& file_self, InterpreterObject* self) {
+void InterpreterObject::load(ArchiverIn& file_self, InterpreterObject* self) {
 	new (&self->mInterpreter) Interpreter();
 }
 
 bool InterpreterObject::running() { return !mInterpreter.finished(); }
 
-void InterpreterObject::exec(obj::ClassObject* self, tp::init_list<Interpreter::GlobalDef> globals) {
+void InterpreterObject::exec(obj::ClassObject* self, tp::InitialierList<Interpreter::GlobalDef> globals) {
 
 	if (running()) {
 		return;

Objects/private/primitives/intobject.cpp

@@ -49,12 +49,12 @@ static alni save_size(IntObject* self) {
 	return sizeof(alni);
 }
 
-static void save(IntObject* self, Archiver& file_self) {
-	file_self.write<alni>(&self->val);
+static void save(IntObject* self, ArchiverOut& file_self) {
+	file_self << self->val;
 }
 
-static void load(Archiver& file_self, IntObject* self) {
-	file_self.read<alni>(&self->val);
+static void load(ArchiverIn& file_self, IntObject* self) {
+	file_self >> self->val;
 }
 
 struct ObjectTypeConversions IntObjectTypeConversions = {

Objects/private/primitives/linkobject.cpp

@@ -28,21 +28,21 @@ alni LinkObject::save_size(LinkObject* self) {
 	return sizeof(alni);
 }
 
-void LinkObject::save(LinkObject* self, Archiver& file_self) {
+void LinkObject::save(LinkObject* self, ArchiverOut& file_self) {
 	if (self->link != NULL) {
 		alni link_object_save_adress = NDO->save(file_self, self->link);
-		file_self.write<alni>(&link_object_save_adress);
+		file_self << link_object_save_adress;
 	}
 	else {
 		alni null = -1;
-		file_self.write<alni>(&null);
+		file_self << null;
 	}
 }
 
-void LinkObject::load(Archiver& file_self, LinkObject* self) {
+void LinkObject::load(ArchiverIn& file_self, LinkObject* self) {
 
 	alni saved_object_adress;
-	file_self.read<alni>(&saved_object_adress);
+	file_self >> saved_object_adress;
 
 	if (saved_object_adress == -1) {
 		self->link = NULL;

Objects/private/primitives/listobject.cpp

@@ -38,25 +38,25 @@ alni ListObject::save_size(ListObject* self) {
 	return (len + 1) * sizeof(alni);
 }
 
-void ListObject::save(ListObject* self, Archiver& file_self) {
+void ListObject::save(ListObject* self, ArchiverOut& file_self) {
 	alni len = self->items.length();
-	file_self.write<alni>(&len);
+	file_self << len;
 
 	for (auto item : self->items) {
 		alni ndo_object_adress = NDO->save(file_self, item.data());
-		file_self.write<alni>(&ndo_object_adress);
+		file_self << ndo_object_adress;
 	}
 }
 
-void ListObject::load(Archiver& file_self, ListObject* self) {
+void ListObject::load(ArchiverIn& file_self, ListObject* self) {
 	new (&self->items) tp::List<Object*>();
 
 	alni len;
-	file_self.read<alni>(&len);
+	file_self >> len;
 
 	for (alni i = 0; i < len; i++) {
 		alni ndo_object_adress;
-		file_self.read<alni>(&ndo_object_adress);
+		file_self >> ndo_object_adress;
 		self->items.pushBack(NDO->load(file_self, ndo_object_adress));
 	}
 }
@@ -78,11 +78,13 @@ alni ListObject::allocated_size(ListObject* self) {
 }
 
 alni ListObject::allocated_size_recursive(ListObject* self) {
-	alni out = self->items.sizeAllocatedMem();
+	ASSERT(false)
+	//alni out = self->items.sizeAllocatedMem();
 	for (auto item : self->items) {
-		out += NDO->objsize_ram_recursive_util(item.data(), item->type);
+		//out += NDO->objsize_ram_recursive_util(item.data(), item->type);
 	}
-	return out;
+	// return out;
+	return 0;
 }
 
 void ListObject::pushBack(Object* obj) {

Objects/private/primitives/methodobject.cpp

@@ -38,20 +38,18 @@ tp::alni MethodObject::save_size(MethodObject* self) {
 	return sizeof(tp::alni);
 }
 
-void MethodObject::save(MethodObject* self, Archiver& file_self) {
+void MethodObject::save(MethodObject* self, ArchiverOut& file_self) {
 	auto script_section = obj::ScriptSection::globalHandle();
-
 	// script_table_file_address
 	tp::alni script_table_file_address = script_section->get_script_file_adress(self->mScript);
-	file_self.write<tp::alni>(&script_table_file_address);
+	file_self << script_table_file_address;
 }
 
-void MethodObject::load(Archiver& file_self, obj::MethodObject* self) {
+void MethodObject::load(ArchiverIn& file_self, obj::MethodObject* self) {
 	auto script_section = obj::ScriptSection::globalHandle();
-
 	// script_table_file_address
 	tp::alni script_table_file_address;
-	file_self.read<tp::alni>(&script_table_file_address);
+	file_self >> script_table_file_address;
 	self->mScript = script_section->get_scritp_from_file_adress(script_table_file_address);
 }
 

Objects/private/primitives/primitives.cpp

@@ -1,83 +0,0 @@
-
-#pragma once
-
-#include "NewPlacement.hpp"
-
-#include "primitives/primitives.h"
-
-#include "Tokenizer.hpp"
-
-void obj::primitives_uninitialize() {
-	obj::NullObject::uninit();
-	obj::MethodObject::UnInitialize();
-}
-
-void obj::primitives_define_types() {
-	
-	using namespace obj;
-	using namespace tp;
-
-	static bool initialized = false;
-	if (initialized) {
-		return;
-	}
-
-	DEBUG_ASSERT(NDO && "Objects library is not initialized");
-
-	NDO->define(&DictObject::TypeData);
-	NDO->define(&IntObject::TypeData);
-	NDO->define(&LinkObject::TypeData);
-	NDO->define(&ListObject::TypeData);
-	NDO->define(&NullObject::TypeData);
-	NDO->define(&StringObject::TypeData);
-	NDO->define(&BoolObject::TypeData);
-	NDO->define(&FloatObject::TypeData);
-	NDO->define(&EnumObject::TypeData);
-	NDO->define(&ClassObject::TypeData);
-	NDO->define(&ColorObject::TypeData);
-	NDO->define(&InterpreterObject::TypeData);
-	NDO->define(&TypeObject::TypeData);
-
-	NDO->type_groups.addType(&DictObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&IntObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&LinkObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&ListObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&NullObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&StringObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&BoolObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&FloatObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&EnumObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&ClassObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&ColorObject::TypeData, {"Primitives"});
-	NDO->type_groups.addType(&InterpreterObject::TypeData, { "scripting" });
-
-	obj::MethodObject::Initialize();
-
-	initialized = true;
-}
-
-namespace obj {
-	objects_api* objects_init();
-	void objects_finalize();
-};
-
-static bool objInit() {
-	obj::objects_init();
-	obj::primitives_define_types();
-	return true;
-}
-
-static void objDeinit() {
-	obj::primitives_uninitialize();
-	obj::objects_finalize();
-}
-
-static tp::ModuleManifest* sModuleDependencies[] = {
-	// &tp::gModuleCompressor,
-	&tp::gModuleMath, 
-	&tp::gModuleStrings,
-	&tp::gModuleTokenizer,
-	NULL
-};
-
-tp::ModuleManifest obj::gModuleObjects = tp::ModuleManifest("Objects", objInit, objDeinit, sModuleDependencies);

Objects/private/primitives/stringobject.cpp

@@ -54,13 +54,13 @@ static alni save_size(StringObject* self) {
 	return {};
 }
 
-static void save(StringObject* self, Archiver& file_self) {
-	self->val.save(&file_self);
+static void save(StringObject* self, ArchiverOut& file_self) {
+	file_self << self->val;
 }
 
-static void load(Archiver& file_self, StringObject* self) {
+static void load(ArchiverIn& file_self, StringObject* self) {
 	new (&self->val) tp::String();
-	self->val.load(&file_self);
+	file_self >> self->val;
 }
 
 alni allocated_size(StringObject* self) {

Objects/private/primitives/typeobject.cpp

@@ -16,17 +16,17 @@ TypeObject* TypeObject::create(const ObjectType* type) {
 
 static alni save_size(TypeObject* self) {
 	tp::String const nameid(self->mTypeRef->name);
-	return nameid.save_size();
+	return nameid.size() + sizeof(nameid.size());
 }
 
-static void save(TypeObject* self, Archiver& file_self) {
+static void save(TypeObject* self, ArchiverOut& file_self) {
 	tp::String const nameid(self->mTypeRef->name);
-	nameid.save(&file_self);
+	file_self << nameid;
 }
 
-static void load(Archiver& file_self, TypeObject* self) {
+static void load(ArchiverIn& file_self, TypeObject* self) {
 	tp::String nameid;
-	nameid.load(&file_self);
+	file_self >> nameid;
 
 	auto idx = NDO->types.presents(nameid);