Ownership

[Manuzor]

Regular reference counting has some problems:

• No one knows when exactly something is deleted
• No one feels responsible for cleaning stuff up, i.e. there is no owner.

Inspired by Rust, I have come up with an ownership system that does reference counting only on special borrowed objects, that wrap the original object. I guess you could say it is a combination of std::unique_ptr and std::shared_ptr.

An example should make things more clear:

class Foo { int data; };
void cleanUpFoo(Foo* pFoo) { delete pFoo; }
void doStuff(kr::Borrowed<Foo> foo) { printf("foo: %d\n", foo->data); }

// ...
auto fooptr = new Foo{ 42 };

// Create an owner for fooptr.
// Ref count will be 0 at this point
kr::Owned<Foo> foo = own(foo, cleanUpFoo);

// Ref count within doStuff is 1, prints "foo: 42",
// and resets the ref count to 0 on return.
doStuff(borrow(foo));

// Invokes cleanUpFoo and resets its internal state.
// If anything was still borrowed at this point,
// an assertion would have triggered.
foo.reset();

Advantages:

• No need for intrusive ref counting or multiple inheritance since there is only exactly one owner.
• You know exactly when Foo gets deleted.
• Everything is very explicit but not to a point where it is inconvenient.
• The deleter can be specified at the time you take ownership, giving you an extra level of flexibility.
• Enables you to take ownership of stack variables. int bar = 42; auto oBar = own(&bar, [](int*){});

On top of this, something like a make function would be possible, which takes care of specifying the deleter for you:

template<typename T, typename Args...>
kr::Owned<T> make(Args...) { /* Use the default allocator, forward args, etc... */ }
kr::Owned<T> makeWith(Allocator* allocator, Args...) { /* Use the default allocator, forward args, etc... */ }
auto foo1 = make<Foo>(42);
auto foo2 = makeWith<Foo>(myFancyAllocator, 42);

TODO

Things that are still left to do at this point:

• Properly test kr::Owned and make it work correctly in the face of const.
• Port everything that uses reference counting in krEngine to use kr::Owned instead.
• Clean up and move old krEngine/referenceCounting stuff to krEngine/ownership.

[Manuzor]

Things done from the TODO list:

• kr::Owned and kr::Borrow now work with const.
• Everything that used kr::RefCounted before now uses kr::Owned or kr::Borrow.
• No need to clean up ref counting stuff. It has been moved to krEngine/ownership though.

This means it would be ready to be merged back. Any volunteers for reviewing?

[Manuzor]

I know there are a lot of changes. If one of you is willing, we could go over the crucial parts together. Not every little change has to be reviewed, of course.

If none of you would like to review this, then I will just merge it back.