class HCategory: public TObject

_HADES_CLASS_DESCRIPTION

HCategory (ABC)

   The HCategory class is an abstract base class. So the real work is
 made by the derived classes. These derived classes correspond to different
 strategies to store the data objects in memory and in file. The classes
 derived from HCategory can also indicate the way they want to be stored in
 a Root tree (the TBranch layout), for that purpose the makeBranch() function
 can be overloaded.

   A HCategory encapsulates one category of data; that is one kind of data
 (mdc raw data,rich rings...), and it is responsible of giving the user
 access to the objects held by that category. The category is also able to
 hold one header with common information for all the objects in the category.

   The class provides functions to access the objects in the category:

   Each data object in the category is stored in a particular location
 (see HLocation), so to access an object you must give its location and use
 the method: getObject(HLocation &aLoc). This method returns one only object,
 if you want a collection with all the objects corresponding to a particular
 location (i.e, all the raw data in the second chamber of the first sector...)
 then use query(TCollection *col,HLocation &aLoc) with col being the
 collection where to store the result. You can also iterate on all the
 objects in the category or the objects corresponding to a particular location
 using the HIterator created by MakeIterator() or MakeReverseIterator()

   The category is also responsible of allocating new objects, this can be
 done through the functions getSlot(HLocation &aLoc) and
 getNewSlot(HLocation &aLoc)  which return a place in memory where to
 allocate the new object (a slot) corresponding to the location aLoc. The
 strategy of letting the HCategory to manage the memory has the advantage
 that it allows the category to have the memory preallocated.

   Example:
    {
     HLocation loc; //Allocates loc pointing to a location
     HMdcRaw *raw; //Declaration of a pointer to a TObject
     HCategory *cat; //Pointer to a generic category

     //loc is set to point to the location (2,2,1); this could be something
     //like: sector 2, mdc 2, plane 1.
     loc.set(3,2,2,1);
     //Ask for the slot at location "loc" and stores its address in raw
     //if there is not such a slot, the getSlot() method will return NULL
     raw=cat->getSlot(loc);
     //If we have a valid slot (raw!=NULL) then allocate a new object of
     //class HMdcRaw at the addres given by raw using the operator
     //"new with placement"
     if (raw!=NULL) raw=new(raw) HMdcRaw;
    }

   Each category can be persistent or not; so if it's persistent it
 will be stored in the output file (if any) and if it's not, then it won't
 be stored in the output file. To control the persistency of a category
 the setPersistency() method is provided

   Here follows a description of the common methods every class inherited
 from HCategory provides:

  TObject *&getNewSlot(HLocation &aLoc)
    Returns a memory slot for location aLoc where you can place a new object
   aLoc gives the indexes for the location of the new object except the last
   one. So the function returns the first empty slot in aLoc.

  TObject *&getSlot(HLocation &aLoc)
     The same as before, but now aLoc gives the complete location of the new
    object
  TObject *getObject(HLocation &aLoc)
    Returns the object at the location aLoc

  TClonesArray *getClones(HLocation &aLoc)
    Returns a clones array with the objects corresponding to the HLocation
    aLoc.

  Bool_t query(TCollection *aCol,HLocation &aLoc,HFilter &aFilter)
    Adds to aCol all objects in the category corresponding to the location
    aLoc and passing the filter aFilter. There are also functions without
    aFilter or without aLoc

  Bool_t filter(HLocation &aLoc,HFilter &aFilter)
  Bool_t filter(HFilter &aFilter)
    The same as before but now the objects not verifying the conditions are
   deleted off the category