Major update: Import dynamic heap structure

map <int, pair<string, shared_ptr<Wrapper> > > heap :
int -> number of the object (all objects are unique)
string -> name of the object
shared_ptr<Wrapper> -> the actuall object wrapped into the Wrapper struct

The Wrapper struct will dynamically keep two pointers to the following classes:
SingleBoxPreference
ListPreference

This way, we can create a map of shared pointers pointing to different objects from different
classes, we call this map, "heap";

*Inserting objects in the heap:
In order to insert an object in the heap, we dynamically create the object (type SingleBoxPreference or ListPreference) we dynamically create a Wrapper object in which we wrap our dynamically created
SingleBox or ListPreference object. Now, we create a smart shared pointer which will keep our wrapped object. Finally, we push this ponter to the heap at its specific position.

*Extracting objects from the heap:
In order to extract an object from the heap we only need its number and its class (SingleBoxPreference or ListPreferece). This way, we dereference the needed shared pointer from the heap and we pass it
to a pointer to the respective class. Dereferencing the shared pointer will give us a Wrapper object which is passed to the pointer-to-class using an overloaded cast operator defined in the
Wrapper struct itself. Now, we can freely use this simple pointer-to-class to perform various operations, dynamically.

Note that this pointer-to-class only points to a wrapped object from the heap , it is not dynamically allocated (using operator "new"), this way we don't have to write the full adress of the
shared pointer from the heap every time we want to do operations on the specific object.

Also, doing some basic code cleanup and code fixes...

More details will be published in the upcoming documentation.