"It is just like inventing the wheel, it has already been done!" -- Someone...
Introducing SSTS -- The (Super) Simple Type System
So a few days ago I started thinking about GLib and GObject and wondered how easy -- or hard -- it would be to create my own base object system. So the first thing that every good hacker does when faced with such a question is to do it, from scratch, without looking at others code.
So after a few hours I had written my base object type with every function that
I would ever need. Than the next day I wrote the first object derived from this
base object. (Still not even compiled the code). On the third day I started writing
tests and ironed out some compile errors, and than I wrote more tests (this time with
the derived object type) and tested everything with valgrind
and ironed
out every memory leak I could find.
Than, I decided to write a new type, a Map... This is where I found out that all the plane sailing that I have had took an abrupt end, and I was faced with a non-trivial problem:
How do I discern a object that is of the type system from an object that is not? I need to be be able to call the objects destructor if it is, and ordinary free () if it was not.
This lead me -- after some non-help from G+ -- to dig though GLib/GObject C code only to find out that the problem is non-trivial. In GLib/GObject it seems that they use a lookup table to find out if an object is or is not of the type GObject.
Action plan:
There is two ways I could do this:
- The sane and hard way -- basically reimplementing what GLib/GObject does.
- The easy but mad way -- just ask the user for a destruction method/function as a parameter.
The first way would be the hardest to implement, and probably course trouble if I were to use GObjects somewhere. But if I do it that way the user of the library would have less work to do.
If I do it the second way it would mean less work, but the end user would probably not be so pleased to have to specify the destruction method for each map. I may even have to have the user specify it for every item in the map.
If I go with Plan A (The Sane, but hard way) it also solves other inheritance related issues: How to know, in large object hierarchies, what object is what type.
The lookup table would contain pointers to every object that is registered with the system (at run-time), during the registration of the object the object must tell the system what types it is (what objects it has inherited from).
The look-up list would have to have two fields per item: a key (the pointer to the object) and a value that is a list of object-types that the object is.
Any way: for those that are interested in this (Super) Simple Type System it can be found on launchpad.
Inga kommentarer:
Skicka en kommentar