class TTreeCacheUnzip: public TTreeCache

 Default Constructor.

 Constructor.

 Initialization procedure common to all the constructors

 destructor. (in general called by the TFile destructor
 destructor. (in general called by the TFile destructor)

add a branch to the list of branches to be stored in the cache
this function is called by TBranch::GetBasket

add a branch to the list of branches to be stored in the cache
this function is called by TBranch::GetBasket

 Set the minimum and maximum entry number to be processed
 this information helps to optimize the number of baskets to read
 when prefetching the branch buffers.

 It's the same as TTreeCache::StopLearningPhase but we guarantee that
 we start the unzipping just after getting the buffers

update pointer to current Tree and recompute pointers to the branches in the cache

 Static function that tells wether the multithreading unzipping
 is activated

 This indicates if the thread is active in this moment...
 this variable is very important because if we change it from true to
 false the thread will stop... ( see StopThreadTreeCacheUnzip() )

 It says if the queue is empty... useful to see if we have to process
 it.

 Here the threads sleep waiting for some blocks to unzip

 This will send the signal corresponfing to the queue... normally used
 when we want to start processing the list of buffers.

 Static function that(de)activates multithreading unzipping
 The possible options are:
 kEnable _Enable_ it, which causes an automatic detection and launches the
 additional thread if the number of cores in the machine is greater than one
 kDisable _Disable_ will not activate the additional thread.
 kForce _Force_ will start the additional thread even if there is only one core.
 the default will be taken as kEnable.
 returns 0 if there was an error, 1 otherwise.

 The Thread is only a part of the TTreeCache but it is the part that
 waits for info in the queue and process it... unfortunatly, a Thread is
 not an object an we have to deal with it in the old C-Style way
 Returns 0 if the thread was initialized or 1 if it was already running

 To stop the thread we only need to change the value of the variable
 fActiveThread to false and the loop will stop (of course, we will have)
 to do the cleaning after that.
 Note: The syncronization part is important here or we will try to delete
       teh object while it's still processing the queue

 This is a static function.
 This is the call that will be executed in the Thread generated by
 StartThreadTreeCacheUnzip... what we want to do is to inflate the next
 series of buffers leaving them in the second cache.
 Returns 0 when it finishes

 Read the logical record header from the buffer buf.
 That must be the pointer tho the header part not the object by itself and
 must contain data of at least maxbytes
 Returns nread;
 In output arguments:
    nbytes : number of bytes in record
             if negative, this is a deleted record
             if 0, cannot read record, wrong value of argument first
    objlen : uncompressed object size
    keylen : length of logical record header
 Note that the arguments objlen and keylen are returned only
 if maxbytes >=16
 Note: This was adapted from TFile... so some things dont apply

 This will delete the list of buffers that are in the unzipping cache
 and will reset certain values in the cache.
 This name is ambiguos because the method doesn't reset the whole cache,
 only the part related to the unzipping
 Note: This method is completely different from TTreeCache::ResetCache(),
 in that method we were cleaning the prefetching buffer while here we
 delete the information about the unzipped buffers

 We try to read a buffer that has already been unzipped
 Returns -1 in case of read failure, 0 in case it's not in the
 cache and n>0 in case read from cache (number of bytes copied).
 pos and len are the original values as were passed to ReadBuffer
 but instead we will return the inflated buffer.
 Note!! : If *buf == 0 we will allocate the buffer and it will be the
 responsability of the caller to free it... it is useful for example
 to pass it to the creator of TBuffer

 static function: Sets the unzip relatibe buffer size
 FABRIZIO: PLEASE DOCUMENT and also in TTree::Set...

 Sets the size for the unzipping cache... by default it should be
 two times the size of the prefetching cache

 UNzips a ROOT specific buffer... by reading the header at the beginning.
 returns the size of the inflated buffer or -1 if error
 Note!! : If *dest == 0 we will allocate the buffer and it will be the
 responsability of the caller to free it... it is useful for example
 to pass it to the creator of TBuffer
 src is the original buffer with the record (header+compressed data)
 *dest is the inflated buffer (including the header)

 This inflates all the buffers in the cache.. passing the data to a new
 buffer that will only wait there to be read...
 We can not inflate all the buffers in the cache so we will try to do
 it until the cache gets full... there is a member called fUnzipBufferSize which will
 tell us the max size we can allocate for this cache.

 note that we will  unzip in the order they were put into the cache not
 the order of the transference so it has to be read in that order or the
 pre-unzipping will be useless.

 startindex is used as start index to check for blks to be unzipped

 returns 0 in normal conditions or -1 if error, 1 if it would like to sleep

 This func is supposed to compete among an indefinite number of threads to get a chunk to inflate
 in order to accommodate multiple unzippers
 Since everything is so async, we cannot use a fixed buffer, we are forced to keep
 the individual chunks as separate blocks, whose summed size does not exceed the maximum
 allowed. The pointers are kept globally in the array fUnzipChunks

 Methods related to the thread

 Methods to get stats