switch to std::tuple for properties
replace custom tuple by std::tuple
Major change to virtual table implementation

Properties' methods are now stored in an table stored as a static member
of the class. Code is a lot shorter and more flexible.
new way to access properties, pseudo property

A `helper' template class is defined outside of the `resource' scope,
it can be specialized for any property even property not defined in the
class so allowing pseudo-property like `rdf:type'.
Investigate constant properties, `rdf:type' for instance should be constant.
New allocator, resources are grouped by type

The goals of the new allocator are:
1. Group all the resources by type, each type has its own memory pool
dynamically allocated (array), those pools can written to a file in
raw binary possibly for later reuse, leading to persistence.
The grouping can be used to speed up SPARQL queries.
2. Pointers can be replaced by `pseudo' pointers: indexes into
the pool cell, they can be made a lot smaller than 8 bytes depending
on the type cardinality. For instance the number of rdfs::Classes is
known at compile time so a pointer to a rdfs::Class (like `rdf::type') should
only be ln2(n) bits. (pointers are templates that can be specialized)

More work is needed to deal with strings and property_array, strings
could be replaced by cstring of set size.
initial support for mmap for data persistence

Each pool (corresponding to a type) mmaps a file in the db/ directory
The problem is that the early introspection creates a new set of
rdfs::Class and rdf::Property, they are never deleted and keep adding
up everytime the program is run.
Solutions:
. clean up before shutting down
. clean up when starting: empty rdfs::Class and rdf::Property pools,
this has the advantage of makinr sure we have a clean slate
. put more logic in storage: does not allow duplicate resources (similar
to rdf::RDF)
custom vector allocator for storage and optimization

Each type gets its own memory pool and the pointer becomes an offset in that pool.
It means that the pointer can be arbitrarily small, if we know we will only ever have 255 instances of class T, we can use pseudo_ptr<T> of size 1 byte.
Generic pointer-like type with custom storage

Template parameters are used to set the storage back-end: free store or memory-mapped files, the pool size and the index size. Using the free store is not the same as using a regular pointer as the pseudo_ptr size depends mainly on the index. The shared_ptr implementation had to be slightly modified to handle pseudo_ptr.
add compile-time check for copy constructor

In order to make pseudo_ptr operations safe by only allowing upcasting.
added type safe version of allocate and deallocate

the pool class is not templated but member functions can be templated for safer pointer arithmetic (instead of mutiplying void* by cell size).
Add a function pointer to class destructor, could add more function pointers stored in a tuple to realize something similar to a virtual function table
Add a simple forward iterator to go through all the occupied cells within a pool.
modification to STORE interface

Experimentation with virtual function-like behaviour
fixed alignement problem with helper<> structure

The union definition to access `next' and `n_cells' members was padding the
structure to 8 byte boundary causing, it has been replaced by a class
with 2 functions to return those fields.
modification to allow data persistence
reuse pseudo_ptr to create vector allocator

simple allocator, generates a forward linked list of empty cell clusters.
When allocating each link is visited until a big enough cluster is found
or end of list is reached, in the latter case 0 is returned and allocation
has failed.
Improvement: order linked list, use external array for fast retrieval
add support for multiple cell allocation for vector

struct info has been modified to store cluster size, need some
check to ensure the info struct is not bigger than the payload
create struct empty_store for classes with no instances

Literal classes (rdf:Literal, xsd:string,...) are only used as symbols
they are never instantiated because they stand for built-in types eg: std::string.
So no pool is created for those types.
new type_id member, specialize pseudo_ptr<const>

if more than one pool can carry the same type, although it should be
avoided, they will share the same type_id member, which can be used as
the rdfs::Class index.
pseudo_ptr<const T...> specializes pointer to constant objects for
instance rdfs::Class or rdf::Property, not implemented yet. The
different casting options must be considered.
fixed major bug with pool's id using hash

Each new pool was given a unique id based on a static counter, the
problem with that approach is that id depends on the execution path, if
in one path some class is not instantiated its pool wont be created and
all following pool's id will be offset by 1 causing havoc.
The solution adopted is to create the pool id with a hash of the class
qualified name eg: `rdfs_Class' (and information about the store and
the constness), only the least significant byte is used (risk of
collision) so it can be used as an index in a 255-cell pool.
More work needed to detect hash&0xff collision and hash&0xff==0.
When using a persistent store the pool id should be written to file so
it can be checked when loading the file.
dynamic pool resizing - free store and mmap

Both free_store and persistent_store are grown when running out of free
cells. Memory is not released when the pool shrinks. There are currently
limit on the maximum size, obviously it should be checked against the
pointer size and available resource.
Fixed major bug with persistent storage + improvements

There was a serious bug: when using persistent storage the file size was
ignored and only the first page was mapped causing major crashes.
The store has now access to the full pseudo_ptr implementation and can
get the maximum addressable space based on the pointer size.
It will also used in the future to facilitate mounting a file read-only.
The pointer size (pseudo_ptr::INDEX) is now a template parameter and
defaults to `unsigned short' that is maximum 2^32 objects.