HMatrixCategory

class HMatrixCategory : public HCategory

    public:

                            HMatrixCategory()
                            HMatrixCategory(Text_t* className, Int_t nSizes, Int_t* sizes, Float_t fillRate = 0.1)
                            HMatrixCategory(const HMatrixCategory&)
                            ~HMatrixCategory()
               virtual void activateBranch(TTree* tree, Int_t splitLevel)
               virtual void Browse(TBrowser* b)
             static TClass* Class()
               virtual void Clear(Option_t* opt)
             virtual Bool_t filter(HFilter& aFilter)
             virtual Bool_t filter(HLocation& aLoc, HFilter& aFilter)
            virtual TClass* getClass()
      virtual const Text_t* getClassName() const
         const TCollection* getCollection() const
              virtual Int_t getEntries()
              virtual Int_t getIndex(HLocation& aLoc)
              virtual Int_t getIndex(TObject* pObj)
          virtual TObject*& getNewSlot(HLocation& aLoc, Int_t* pIndex = 0)
           virtual TObject* getObject(HLocation& aLoc)
           virtual TObject* getObject(Int_t index)
                      Int_t getSize(Int_t aIdx)
                   TArrayI* getSizes()
          virtual TObject*& getSlot(HLocation& aLoc, Int_t* pIndex = 0)
            virtual TClass* IsA() const
             virtual Bool_t isSelfSplitable()
               virtual void makeBranch(TBranch* parent)
         virtual TIterator* MakeIterator(Option_t* opt = "catIter", Bool_t dir = kIterForward)
           HMatrixCategory& operator=(const HMatrixCategory&)
             virtual Bool_t query(TCollection* aCol, HFilter& aFilter)
             virtual Bool_t query(TCollection* aCol, HLocation& aLoc)
             virtual Bool_t query(TCollection* aCol, HLocation& aLoc, HFilter& aFilter)
                       void setup(Text_t* className, Int_t nSizes, Int_t* sizes, Float_t fillRate = 0.1)
               virtual void ShowMembers(TMemberInspector& insp, char* parent)
               virtual void Streamer(TBuffer& b)
                       void StreamerNVirtual(TBuffer& b)

Data Members

    protected:

       HIndexTable* fIndexTable  Table of the position in fData of data objects
              Int_t fNDataObjs   Number of data objects actually stored.
      TClonesArray* fData        Container for the data in the Matrix category;

Class Description

HMatrixCategory

  In this particular HCategory all the objects belonging to the category
 are stored in a matrix-like fashion; so before start using the category it
 is needed to indicate the number of indexes in this matrix and the range of
 each index

  When the matrix category is stored in a tree it creates one superbranch
 holding one subbranch per data member in the objects held by the category.
 All the objects held by the category are stored through that superbranch.

Default constructor

 Creates a HMatrixCategory holding objects of class "className" clasified
by nSizes indexes (giving their location) whose maximun values are the
indicated in the vector "sizes".

 However it only allocates memory for fillRate*(maximun number of objects)
data objects.

Destructor

This method sets up a category.

Input:
  className ---> a string with the name of the object's class stored in
                 the category
  nSizes ---> Number of indexes needed to access an object (fBranchingLevel)
  sizes ---> a vector of ints containing the maximum value for each of the
             indexes before.
  fillRate---> Expected fill factor in the category
               (number of slots used)/(maximun number of slots)

Returns the class' name of the objects held by the category

returns an array of ints with the maximun value for the indexes used to
get an object

Returns the maximun value of the index aIdx

Activates the branches in tree matching the appropiate names.

This function should not be called, since HMatrixCategory is not self
splittable

Determines if the category can be automatically split or it has
its own splitting algorithm (in this last case the function makeBranch is
called for splitting).

returns kFALSE

Should not be used for HMatrixCategory

Returns a memory address corresponding to the HLocation aLoc, where a new
object can be instantiated

Returns the object at the HLocation aLoc (see HCategory)

Returns the object at index in internal TClonesArray

Puts all objects in the category which pass the HFilter aFilter in the
collection pointed by aCol.

Puts all objects in the category corresponding to the HLocation aLoc in
the collection pointed by aCol

Puts all the objects in the category passing the HFilter aFilter and
corresponding to the HLocation aLoc into the collection pointed by aCol

see HCategory

see HCategory

Returns an iterator, which iterates in the direction dir and (as default)
throuhg the whole category.

 see HCategory

Browse objects in this category

 Stream an object of class HMatrixCategory.

Inline Functions

        const TCollection* getCollection() const
                     Int_t getEntries()
                     Int_t getIndex(HLocation& aLoc)
                     Int_t getIndex(TObject* pObj)
                   TClass* Class()
                   TClass* IsA() const
                      void ShowMembers(TMemberInspector& insp, char* parent)
                      void StreamerNVirtual(TBuffer& b)
           HMatrixCategory HMatrixCategory(const HMatrixCategory&)
          HMatrixCategory& operator=(const HMatrixCategory&)