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

 Fill the cache buffer with the branches in the cache.

 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.

 This will traverse the queue and read all the buffers to put them
 in the cache... after reading each buffer it will send a signal and
 if someone is waiting for it, it will wake up and will check the queue
 again to see if the buffer it was waiting for was the buffer that was
 just processed.
 It works that way because I can not have one signal per-buffer...
 instead there is only one signal and all the methods waiting for buffer
 will know that a "new" buffer has been processed (even if that particular
 method is not the one waiting for the buffer)

 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 the counter part of SendSignal() and is used to wait for a buffer
 that is in the queue and will be processed soon (instead of making a new
 call)

 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 unzipping 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

 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 by parts... there is a member calle fUnzipBufferSize which will
 tell us the size we can allocate for this cache so we will divide
 the prefeteched cche in chunks of this size and we will try to unzip then
 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.
 pos and len are used to see where we have to start unzipping...
 and for how long..
 returns 0 in normal conditions or -1 if error

 Methods related to the thread

 Methods to get stats