Apply cpp naming to files

Objects/private/primitives/LinkObject.cpp

@@ -0,0 +1,104 @@
+
+#include "primitives/LinkObject.hpp"
+
+using namespace obj;
+using namespace tp;
+
+void LinkObject::constructor(Object* self) { NDO_CAST(LinkObject, self)->link = 0; }
+
+void LinkObject::destructor(LinkObject* self) {
+	if (self->link) NDO->destroy(self->link);
+}
+
+void LinkObject::copy(Object* self, const Object* in) { NDO_CAST(LinkObject, self)->setLink(NDO_CAST(LinkObject, in)->link); }
+
+LinkObject* LinkObject::create(Object* in) {
+	NDO_CASTV(LinkObject, NDO->create("link"), out)->link = in;
+	return out;
+}
+
+alni LinkObject::save_size(LinkObject* self) { return sizeof(alni); }
+
+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 << link_object_save_adress;
+	} else {
+		alni null = -1;
+		file_self << null;
+	}
+}
+
+void LinkObject::load(ArchiverIn& file_self, LinkObject* self) {
+
+	alni saved_object_adress;
+	file_self >> saved_object_adress;
+
+	if (saved_object_adress == -1) {
+		self->link = NULL;
+	} else {
+		self->link = NDO->load(file_self, saved_object_adress);
+		NDO->refinc(self->link);
+	}
+}
+
+tp::Buffer<Object*> LinkObject::childs_retrival(LinkObject* self) {
+	tp::Buffer<Object*> out;
+	if (self->link) out.append(self->link);
+	return out;
+}
+
+alni LinkObject::allocated_size(LinkObject* self) { return sizeof(Object*); }
+
+alni LinkObject::allocated_size_recursive(LinkObject* self) {
+	alni out = sizeof(Object*);
+	if (self->link) {
+		out += NDO->objsize_ram_recursive_util(self->link, self->link->type);
+	}
+	return out;
+}
+
+Object* LinkObject::getLink() { return link; }
+
+void LinkObject::setLink(Object* obj) {
+	if (link) NDO->destroy(link);
+	if (obj) NDO->refinc(obj);
+	link = obj;
+}
+
+static auto tm_set = TypeMethod{ .nameid = "set", .descr = "sets the link", .args = { { "target", NULL } }, .exec = [](const TypeMethod* tm) {
+																	auto const self = (LinkObject*) tm->self;
+																	auto const target = tm->args[0].obj;
+																	self->setLink(target);
+																} };
+
+static auto tm_get = TypeMethod{ .nameid = "get",
+																 .descr = "gets the link",
+																 .exec =
+																	 [](const TypeMethod* tm) {
+																		 auto const self = (LinkObject*) tm->self;
+																		 auto link = self->getLink();
+																		 if (link) {
+																			 tm->ret.obj = link;
+																		 }
+																	 },
+																 .ret = { "the link", NULL } };
+
+struct obj::ObjectType LinkObject::TypeData = { .base = NULL,
+																								.constructor = LinkObject::constructor,
+																								.destructor = (object_destructor) LinkObject::destructor,
+																								.copy = LinkObject::copy,
+																								.size = sizeof(LinkObject),
+																								.name = "link",
+																								.convesions = NULL,
+																								.save_size = (object_save_size) LinkObject::save_size,
+																								.save = (object_save) LinkObject::save,
+																								.load = (object_load) LinkObject::load,
+																								.childs_retrival = (object_debug_all_childs_retrival) LinkObject::childs_retrival,
+																								.allocated_size = (object_allocated_size) LinkObject::allocated_size,
+																								.allocated_size_recursive = (object_allocated_size_recursive) LinkObject::allocated_size_recursive,
+
+																								.type_methods = { .methods = {
+																																		&tm_set,
+																																		&tm_get,
+																																	} } };