NavSet.cxx

Go to the documentation of this file.

// $Id: NavSet.cxx,v 1.15 2005/03/16 16:06:35 west Exp $
//
// NavSet
//
// Package: Nav (Navigational Model).

// Begin_Html<img src="../../pedestrians.gif" align=center>
// <a href="../source_warning.html">Warning for beginners</a>.<br>
// Also see <a href="../../root_crib/index.html">The ROOT Crib</a> and
// <a href="../index.html">The MINOS Class User Guide</a>End_Html
//
// N. West 03/20000
//
// Concept:  Sharable, mapable, sortable, selectable, sliceable
//           array of void* derived from set or relationship.
//   
// Purpose:  A NavSet is a a generic set that can be:-
//
//           o  Shareable by any number of iterators.
//           o  Can represent a mapping across a relationship
//              i.e. the set of class A objects associated with
//              a specific object of class B.
//           o  Ordered via a user configured ordering object.
//           o  Individual members can be selected via a user 
//              configured selection object.
//           o  Access can be restricted to those members whose
//              ordering value is within a user supplied range.
//
//           The underlying set are void* pointers but all accesss to
//           the set is via a type safe XxxItr class inheriting from
//           NavItr.
//

#include <algorithm>

#include "Navigation/NavItr.h"
#include "Navigation/NavKeyFunc.h"
#include "Navigation/NavSet.h"
#include "LeakChecker/Lea.h"
#include "Lattice/Lattice.h"
#include "MessageService/MsgService.h"
#include "TCollection.h"

typedef  NavSet::SliceLimits            SliceLimits;
typedef  list<NavItr*>::const_iterator  ConstItrItr;
typedef  list<NavItr*>::iterator        ItrItr;
typedef  vector<void*>::iterator        ObjItr;
typedef  vector<SliceLimits>::iterator  SliceLimitsItr;
         
ClassImp(NavSet)

//   Definition of static data members
//   *********************************

CVSID("$Id: NavSet.cxx,v 1.15 2005/03/16 16:06:35 west Exp $");

NavSet* NavSet::fgCurrent = 0;
NavSet::EXLessThanYAmbResolve NavSet::fgXLessThanYAmbResolve = NavSet::kFirstGreater;

// Definition of member functions (alphabetical order)
// ***************************************************


//.....................................................................

Bool_t NavSet::AdoptSelectKeyFunc(NavKeyFunc* keyFunc,
                                  Bool_t update) {
//
//
//  Purpose:  Replace current selection function with supplied.
//
//  Arguments: 
//    keyFunc      in    New key function or 0 to cancel selection.
//                       NB NavKey takes control of the NavKey and
//                          will eventually delete it.  The user must
//                          not access the object again.
//    update       in    Set kTRUE (default) if set to be updated.
//
//  Return:    kTRUE if keyFunc was compatible with this NavSet.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Delete any current selection object.
//
//  o If supplied NavKeyFunc is compatible, adopt it otherwise delete 
//    it.
//
//  o Update the set and Reset all iterators if required.


//  Program Notes:-
//  =============

//  Suppressing updating saves time if further select/sort functions are
//  to be applied.
//  The user must subsquently call Update() to bring the set up to date.

  Bool_t mustUpdate = kFALSE;
  if ( fSelectFunc ) {
    delete fSelectFunc;
    fSelectFunc = 0;
    fSelectFuncInvert = kFALSE;
    mustUpdate = kTRUE;
  }

  Bool_t funcOK     = kTRUE;
  fSelectFunc       = keyFunc;
  fSelectFuncInvert = kFALSE;
  if ( fSelectFunc && ! KeyFunAcceptable(keyFunc) ) {
    delete fSelectFunc;
    fSelectFunc = 0;
    funcOK = kFALSE;
  }

  if ( update ) {
    if ( mustUpdate) Update();
    else             DoSelectFunction();
  }

  return funcOK;

}

//.....................................................................

Bool_t NavSet::AdoptSortKeyFunc(NavKeyFunc* keyFunc,
                                Bool_t dropExisting,
                                Bool_t update) {
//
//
//  Purpose:  Replace current ordering function with supplied and 
//            resort if required.
//
//  Arguments: 
//    keyFunc      in    New key function or 0 to cancel sorting.
//                       NB NavKey takes control of the NavKey and
//                          will eventually delete it.  The user must
//                          not access the object again.
//    dropExisting in    Set kTRUE (default) if existing functions are
//                       to be dropped (also done if keyFunc = 0).
//    update       in    Set kTRUE (default) if set to be updated.
//
//  Return:    kTRUE if keyFunc was compatible with this NavSet.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Delete any current set ordering objects.
//
//  o If supplied NavKeyFunc is compatible, adopt it otherwise 
//    delete it.
//
//  o Resort set if reqired (sort == kTRUE).


//  Program Notes:-
//  =============

//  Suppressing updating saves time if further select/sort functions are
//  to be applied.
//  The user must subsquently call Update() to bring the set up to date.

// Must do a full update (rather than just resort the current selected
// set) if selection may have changed i.e. if the ordering associated
// with any slice changes.
  Bool_t mustUpdate = kFALSE;

  if ( dropExisting || ! keyFunc ) {
    mustUpdate = fSliceLimits.size() > 0;
    DeleteOrderFuncs();
  }

  Bool_t funcOK = kTRUE;
  if ( keyFunc  && ! KeyFunAcceptable(keyFunc) ) {
    funcOK = kFALSE;
    delete keyFunc;
    keyFunc = 0;
  }
  if ( keyFunc ) {
    if ( fSliceLimits.size() > fOrderFuncs.size() ) mustUpdate = kTRUE;
    fOrderFuncs.push_back(keyFunc);
  }

  if ( update ) {
    if ( mustUpdate) Update();
    else             DoSort();
  }

  return funcOK;

}

//.....................................................................

UInt_t NavSet::Attach(NavItr* itr) {
//
//
//  Purpose:  Attach iterator.
//
//  Arguments: 
//    itr          in    Attaching iterator.
//
//  Return:    Number of iterators attached (including the current one)
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Add iterator to the list of attached iterators and return the new 
//    size of the set.

//  Program Notes:-
//  =============

//  None.

  fItrs.push_back(itr);
  return fItrs.size();

}

//.....................................................................

void NavSet::DeleteOrderFuncs() {
//
//
//  Purpose: Delete any owned sort functions 
//
//  Arguments: None.
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Delete any owned sort functions 

//  Program Notes:-
//  =============

//  None.

  for ( vec_key_funcs_itr_t itr = fOrderFuncs.begin();
        itr != fOrderFuncs.end();
        ++itr ) delete *itr;
  fOrderFuncs.clear();
}

//.....................................................................

UInt_t NavSet::Detach(NavItr* itr) {
//
//
//  Purpose:  Detach iterator.
//
//  Arguments: 
//    itr          in    Detaching iterator.
//
//  Return:    Number of iterators still attached (excluding the current one)
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Remove iterator to the list of detached iterators and return the new 
//    size of the set.

//  Program Notes:-
//  =============

//  When the value 0 is returned the calling NavItr must delete the NavSet.


  ItrItr entry = find(fItrs.begin(), fItrs.end(), itr);

  if ( entry == fItrs.end() ) {
    MSG("Nav", Msg::kError) << "Cannot find detaching iterator " 
      << itr << endl;
  }
  else {
    fItrs.erase(entry);
  }

  return fItrs.size();

}


//.....................................................................

void NavSet::DoSelectFunction() {
//
//
//  Purpose: Remove set members that fail the current selection function. 
//
//  Arguments: None
//
//  Return:    n/a.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Apply the latest selection function and reset all iterators.

//  Program Notes:-
//  =============

//  This member function is used when a new selection function is added as 
//  this can only reduce set membership and consequently sorting can be 
//  avoided.

// No action if there is no function.
  if ( ! fSelectFunc ) return;

// Select into a temporay array.

  vector<void*> temp;
  for ( ObjItr itr = fArraySel.begin(); itr != fArraySel.end(); itr++ ) {
    void* obj = *itr;
    if ( ( (*fSelectFunc)(obj).ForceLong_t() == 0 )
         ==  fSelectFuncInvert ) temp.push_back(obj);
  }

// Copy back to selected array.

  fArraySel = temp;

// Inform all iterators.

  ResetItrs();
 
}

//.....................................................................

void NavSet::DoSelectSlice() {
//
//
//  Purpose: Remove set members that fail the latest slice. 
//
//  Arguments: None
//
//  Return:    n/a.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Apply the latest slice to the current set and reset all iterators.

//  Program Notes:-
//  =============

//  This member function is used when a new slice is added as this can
//  only reduce set membership and consequently sorting can be avoided.

// No action if there are no slice limits or no corresponding order function.

  Int_t rank = fSliceLimits.size();
  rank--;
  int size = fOrderFuncs.size();
  if ( rank < 0 || rank+1 > size ) {
    if ( rank+1 > size ) MSG("Nav", Msg::kWarning) 
        << "Attempting to slice in dimension " << rank +1
        << " (i.e. rank " << rank <<  "),\n "
        << "   but sort functions only defined for first " << size
        << " dimension(s)" << endl;
    return;
  }

  NavKeyFunc* func = fOrderFuncs[rank];
  SliceLimits& lim = fSliceLimits[rank];
  NavKey& keyLo = lim.Lo;
  NavKey& keyHi = lim.Hi;

// Select into a temporay array.

  vector<void*> temp;
  for ( ObjItr itr = fArraySel.begin(); itr != fArraySel.end(); itr++ ) {
    void* obj = *itr;
    NavKey key = (*func)(obj);
    if ( keyLo.CompareValue(key) <= 0 && keyHi.CompareValue(key) >= 0
        ) temp.push_back(obj);
  }

// Copy back to selected array.

  fArraySel = temp;

// Inform all iterators.

  ResetItrs();
 
}

//.....................................................................

void NavSet::DoMap() {
//
//
//  Purpose:  Map (select) set associated with object on far side
//            of Lattice.
//
//  Arguments: None.
//
//  Return:    n/a.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o If fFar = 0 cancel association with far side object.
//
//  o Otherwise search for far object on other side of Lattice
//    and if found replace set with that associated with it,
//    otherwise make set empty.
//
// o Resestablish sort order and slice, if any, and reset all associated
//   iterators to the start of their range.

//  Program Notes:-
//  =============

//  Mapping only applies to sets based on Lattices, but for
//  this operation TClonesArrays are treated as one-sided
//  Lattices i.e. mapping returns a null set but cancelling
//  restores the full set.

  if ( fFar ) {
    if ( fLattice ) Fill( fLattice, fSide, fFar);
    else  {
      fArrayFull.clear();
      fArraySel.clear();
    }
  }
  else {
    if ( fLattice )       Fill( fLattice, fSide);
    else if ( fTCollection ) Fill( fTCollection, fClassname, fOffset);
  }

  Update();

}

//.....................................................................

void NavSet::DoSort() {
//
//
//  Purpose:  Sort object set using current set ordering function.
//
//  Arguments: None
//
//  Return:    n/a.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o If there currently is an associated ordering function resort
//    set.
//
// o  Reset all iterators.


//  Program Notes:-
//  =============

//  None.

  if ( fOrderFuncs.size() ) {
//  Prepare the static function XLessThanY.
    fgCurrent = this;
    sort(fArraySel.begin(), fArraySel.end(), NavSet::XLessThanY);
  }

  ResetItrs();

}

//.....................................................................

UInt_t NavSet::Fill(const TCollection* source, 
                    const Text_t* classname, 
                    Int_t offset){
//
//
//  Purpose:  Fill vector from source, offsetting each object address
//
//  Arguments: 
//    source       in    Source set
//    classname    in    Name of class objects.
//    offset       in    Pointer offset: Object adr - TObject adr
//
//  Return:    Number of objects in vector.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Fill vector from TCollection, checking that each object is, or 
//    inherits from, classname.
//
//  o Offset each object address by offset.


//  Program Notes:-
//  =============

//  The offset is needed because all object's are stored by their 
//  TObject address which may not be the same as the target object's 
//  address.

//  N.B. objects whose TObject address is not the same as the target
//  may cause problems in TClonesArrays, for there is an implicit 
//  assumption in TClonesArray the address returned by new is the 
//  TObject address.


//  Vector may not be empty, e.g. after breaking a mapping.

  fArrayFull.clear();

  TIter sourceIter(source);
  TObject* sourceObj;

  Bool_t ok                = kTRUE;
  Bool_t suppressClassCheck = kFALSE;

  if ( strcmp(classname,"???") == 0 ) {
    MSG("Nav", Msg::kWarning) << "Class name set to ??? - cannot validate set!" << endl;
    suppressClassCheck = kTRUE;
  } 
  while ( (sourceObj = sourceIter.Next()) ) {
    if ( ok && ( suppressClassCheck || sourceObj->InheritsFrom(classname) ) 
        ) {
      void* targetObj = (void*) ( (Char_t*) sourceObj + offset );
      fArrayFull.push_back(targetObj);
    }
    else if ( ok ) {
      MSG("Nav", Msg::kError) << "Cannot construct " << classname
        << " iterator, supplied TCollection contains " 
        << sourceObj->ClassName()<< " objects; set will be empty." 
        << endl;
      fArrayFull.clear();
      ok = kFALSE;
    }
  }
  
// Transfer to selected and sorted array.
  fArraySel = fArrayFull;

  return fArraySel.size();
}

//.....................................................................

UInt_t NavSet::Fill(const Lattice* source, ESide side){
//
//
//  Purpose:  Fill vector from one side of a Lattice.
//
//  Arguments: 
//    source       in    Source relationship set
//    side         in    Side of relationship (either kLeft or kRight).
//
//  Return:    Number of objects in vector.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Fill vector from one side of a lattice..


//  Program Notes:-
//  =============

//  None..



//  Vector may not be empty, e.g. after breaking a mapping.

  fArrayFull.clear();

  if ( side != kLeft && side != kRight ) {
    MSG("Lat", Msg::kError) << "Illegal value for side: " << (Int_t) side 
                            << endl;
  }
  else if ( ! source ) {
    MSG("Lat", Msg::kError) << "No Lattice supplied" << endl;
  }
  else {
    source->GetAllIDs( (Lattice::ESide) side, fArrayFull);
  }

// Transfer to selected and sorted array.
  fArraySel = fArrayFull;

  return fArraySel.size();

}

//.....................................................................

UInt_t NavSet::Fill(const Lattice* source, ESide side, const void* far){
//
//
//  Purpose:  Fill vector from one side of a Lattice that associates 
//            one member on the far side of the Lattice.
//
//  Arguments: 
//    source       in    Source relationship set
//    side         in    Side of reltionship (either kLeft or kRight).
//    far          in    member on far side of Lattice.
//
//  Return:    Number of objects in set.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Fill vector from one side of a lattice that associates 
//     one member on the far side of the Lattice.


//  Program Notes:-
//  =============

//  None.



//  Vector may not be empty, e.g. if called from Map.

  fArrayFull.clear();

  if ( side != kLeft && side != kRight ) {
    MSG("Lat", Msg::kError) << "Illegal value for side: " << (Int_t) side 
                            << endl;
  }
  else if ( ! source ) {
    MSG("Lat", Msg::kError) << "No Lattice supplied" << endl;
  }
  else {
    ESide otherSide = ESide(kLeft + kRight - side);
// The casting away of const on far is unavoidable but harmless; 
// Lattice passes ID by value but in MINOS these IDs are void*.
    source->GetFarIDs( (Lattice::ESide) otherSide, (void*)far, fArrayFull);
  }

// Transfer to selected and sorted array.
  fArraySel = fArrayFull;

  return fArraySel.size();

}

//.....................................................................

NavKey NavSet::GetNavKey(Int_t index, Int_t keyRank) const {
//
//
//  Purpose:  Return NavKey associated with supplied index and rank.
//
//  Arguments: 
//    index        in    Index to be tsted
//    keyRank      in    Rank of key (=0 primary, =1 secondary etc.)
//
//
//  Return: NavKey associated with supplied index and rank or NavKey(0)
//          if none.   
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Return NavKey associated with supplied index and rank.

//  Program Notes:-
//  =============

//  None.

  int size = fOrderFuncs.size();
  if (    IsWithinLimits(index) 
       && keyRank >= 0 
       && keyRank < size 
     ) return fOrderFuncs[keyRank]->GetKey(fArraySel[index]);
  return 0;

}

//.....................................................................

void NavSet::GetZone(Int_t limLo,   Int_t limHi, 
                     Int_t index,   Int_t rank, 
                     Int_t& zoneLo, Int_t& zoneHi) const {
//
//
//  Purpose:  Find zone limits around a given index of specified rank.
//
//  Arguments: 
//   limLo      in    Lower possible limit on zone
//   limHi      in    Upper possible limit on zone
//   index      in    Start point for search
//   rank       in    Rank of order function
//   zoneLo     out   Lower limit on zone
//   zoneHi     out   Upper limit on zone
//
//  Return:    n/a  (output via zoneLo and zoneHi)
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Starting at supplied index find zone i.e. region limited by
//    (limLo,limHi) within which the NavKey for order function of
//    supplied rank remains constant.
//
//  o If there is no order function of supplied rank, then treat
//    the supplied region as a single zone.

//  Program Notes:-
//  =============

//  None.

//  Protect against silly values.

  if ( limLo < 0             ) limLo = 0;
  if ( index < limLo         ) index = limLo;
  if ( limHi > GetMaxIndex() ) limHi = GetMaxIndex();
  if ( index > limHi         ) index = limHi;

// If no ordering function, or null range return the full range

  int size = fOrderFuncs.size();
  if ( rank >= size || limLo > limHi ) {
    zoneLo = limLo;
    zoneHi = limHi;
    return;
  }

  NavKeyFunc* func = fOrderFuncs[rank];
  NavKey key       = (*func)(fArraySel[index]);

  zoneLo = index;
  while (    zoneLo > limLo 
          && key.CompareValue((*func)(fArraySel[zoneLo-1])) == 0 
        ) --zoneLo;

  zoneHi = index;
  while (    zoneHi < limHi 
          && key.CompareValue((*func)(fArraySel[zoneHi+1])) == 0 
        ) ++zoneHi;

}

//.....................................................................

void NavSet::Init() {
//
//
//  Purpose:  Initialise empty object.
//
//  Arguments: None.
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Initialise empty object.

//  Program Notes:-
//  =============

//  None.

  fArrayFull.clear();
  fArraySel.clear();
  fFar              = 0;
  fItrs.clear();
  fSelectFunc       = 0;
  fSelectFuncInvert = kFALSE;
  fSetSize          = 0; 

  fLattice          = 0;
  fSide             = kLeft;

  fClassname        = 0;
  fOffset           = 0;
  fTCollection      = 0;
 

}

//.....................................................................

Bool_t NavSet::IsSelected(Int_t index) const {
//
//
//  Purpose:  Determine if supplied index addresses to a selected 
//            object.
//
//  Arguments: 
//    index        in    Supplied index.
//
//  Return:    kTRUE if index addresses to a selected object.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Return kTRUE if supplied index addresses to a selected object,
//    otherwise return kFALSE.

//  Program Notes:-
//  =============

//  None.

  return IsWithinLimits(index);
}
//.....................................................................

void NavSet::InvertSelection(Bool_t set, Bool_t update) {
//
//
//  Purpose:  Set or clear the select function iverter and update if required

  if ( fSelectFuncInvert == set ) return;
  fSelectFuncInvert = set;
  if ( update && fSelectFunc ) this->Update();

}

//.....................................................................

Bool_t NavSet::IsWithinLimits(Int_t index) const {
//
//
//  Purpose:  Determine if supplied index is within limits.
//
//  Arguments: 
//    index        in    Supplied index.
//
//  Return:    kTRUE if index is within limits.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Return kTRUE if supplied index is within limits, otherwise 
//    return kFALSE.

//  Program Notes:-
//  =============

//  None.

  int size = fArraySel.size();
  return (    index >= 0 
           && index+1 <= size  ) ? kTRUE : kFALSE;

}
//.....................................................................

Bool_t NavSet::KeyFunAcceptable(NavKeyFunc* keyFunc) const {
//
//
//  Purpose:  See if key function can be adopted.
//
//  Arguments: 
//    keyFunc      in    New key function or 0.
//
//  Return:    kTRUE if keyFunc can be used with this NavSet.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o 0 is always acceptable. Other are if compatible and have
//      defined functions.

//  Program Notes:-
//  =============

//  None.

  if ( ! keyFunc ) return 1;

  if ( ! keyFunc->IsCompatible(this) ) {
    MSG("Nav", Msg::kError) << "XxxKeyFunc is not compatible." << endl;
    return 0;
  }

  if ( ! keyFunc->FunDefined() ) {
    MSG("Nav", Msg::kError) << "XxxKeyFunc has no function defined." << endl;
    return 0;
  }

  return 1;

}
//.....................................................................

NavSet::NavSet(const TCollection* source, 
               const Text_t* classname, 
               Int_t offset/*=0*/ ) {
//
//
//  Purpose:  Constructor
//
//  Arguments: 
//    source       in    Source set
//    classname    in    Name of class objects.
//    offset       in    Pointer offset: Object adr - TObject adr
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Fill vector from TCollection.


//  Program Notes:-
//  =============

//  None.

  LEA_CTOR    //Leak Checker

  Init();
  fClassname   = classname;
  fOffset      = offset;
  fTCollection = source;
  Fill(source, classname, offset); 
  fSetSize = fArrayFull.size();

}

//.....................................................................

NavSet::NavSet(const Lattice* source, ESide side) {
//
//
//  Purpose:  Constructor
//
//  Arguments: 
//    source       in    Source relationship.
//    side         in    Side of reltionship (either kLeft or kRight).
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Fill vector from one side of a lattice..


//  Program Notes:-
//  =============

//  None.

  LEA_CTOR    //Leak Checker

  Init();
  fLattice = source;
  fSide    = side;
  Fill(source, side); 
  fSetSize = fArrayFull.size();

}
//.....................................................................

NavSet::~NavSet() {
//
//
//  Purpose: Destructor
//
//  Arguments: 
//    None.
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Destroy object.


//  Program Notes:-
//  =============

//  None.

  LEA_DTOR    //Leak Checker

  DeleteOrderFuncs();
  delete fSelectFunc;
  fSelectFunc = 0;

}

//.....................................................................

void NavSet::ResetItrs() const {
//
//
//  Purpose:  Reset all associated NavItrs
//
//  Arguments: None.
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Send all associated NavItrs their ResetSet message.

//  Program Notes:-
//  =============

//  None.

  for (ConstItrItr itr = fItrs.begin(); itr != fItrs.end(); itr++) {
    (*itr)->ResetSet();
  }

}
//.....................................................................

UInt_t NavSet::Size() const{
//
//
//  Purpose:  Return the total set size disregarding selection.
//
//  Arguments: None
//
//  Return:    The total set size disregarding selection.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Return the total set size disregarding selection.
 

//  Program Notes:-
//  =============

//  None.

    return fSetSize;
}
//.....................................................................

UInt_t NavSet::SizeSelect() const{
//
//
//  Purpose:  Return the number currently selected.
//
//  Arguments: None
//
//  Return:    The number currently selected.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Return the number currently selected.

//  Program Notes:-
//  =============

//  None.

  return fArraySel.size();

}
//.....................................................................

void NavSet::Slice(NavKey lo, NavKey hi, Bool_t update) {
//
//
//  Purpose:  Define and appply new slice limits.
//
//  Arguments: 
//    lo           in Lower slice limit.
//    hi           in Upper slice limit.
//    update       in    Set kTRUE (default) if set to be updated.
//
//  Return:    n/a.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o  Set slice limits and reslice set.

//  Program Notes:-
//  =============

//  Suppressing updating saves time if further select/sort functions are
//  to be applied.
//  The user must subsquently call Update() to bring the set up to date.
  
  fSliceLimits.push_back(SliceLimits(lo,hi));
  if ( update ) DoSelectSlice();

}

//.....................................................................

void NavSet::Update() {
//
//
//  Purpose:  Reapply all current selection and sorting.
//
//  Arguments: None.
//
//  Return:    n/a
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o Starting from unselected, unsorted array, fill out selected array
//    applying all current selection and sorting.

//  Program Notes:-
//  =============

//  None.

  fArraySel.clear();

  Int_t rankMax = fSliceLimits.size() < fOrderFuncs.size()
                 ? fSliceLimits.size() : fOrderFuncs.size();

  for ( ObjItr itr = fArrayFull.begin(); itr != fArrayFull.end(); itr++ ) {
    void* obj = *itr;

//  Test function.
    if (    fSelectFunc 
         && ( (*fSelectFunc)(obj).ForceLong_t() != 0 ) == fSelectFuncInvert ) continue;

//  Test slices.
    Bool_t withinLimits = kTRUE;
    for ( Int_t rank = 0; rank < rankMax; ++rank ) {
      NavKey key       = (*fOrderFuncs[rank])(obj);
      SliceLimits& lim = fSliceLimits[rank];
      if (    lim.Lo.CompareValue(key) > 0 
           || lim.Hi.CompareValue(key) < 0 ) {
        withinLimits = kFALSE;
        break;
      }
     }
    if ( withinLimits ) fArraySel.push_back(obj);
  }

  DoSort();
    
}

//.....................................................................

Bool_t NavSet::XLessThanY(void* x, void* y) {
//
//
//  Purpose:  Static function to compare two set objects 
//
//  Arguments: 
//    x            in    First set object.
//    y            in    Second set object.
//
//  Return:    kTRUE if x < y.
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o If there is a current NavSet object that has set ordering
//    NavKeyFuncs, get and compare the two NavKey values and return
//    the result, using lower level NavKeyFuncs to break ambiguity
//    otherwise resolve using fgXLessThanYAmbResolve. 

//  Program Notes:-
//  =============

//  NavSet objects pass this function to the STL sort algorithm. 

//  The only purpose of fgXLessThanYAmbResolve is to change the way
//  order degeneracies are broken in an attempt to uncover bugs that
//  produce different results dependent on such ordering changes.
//
//  To change add the following to your job macro:-
//
//      NavSet::fgXLessThanYAmbResolve = NavSet::kChooseByAddress;
//
//  This changes from the default(kFirstGreater). If the results 
//  change in a significant way then this indicates a bug.

//  Caution:  It's tempting to define kSecondGreater as this would be reproducible,
//  unlike kChooseByAddress which, because the heap manager can return a
//  different addresses when presented with the same sequence of requests,
//  is not.  Indeed the temptation has been succumbed to but it ends in
//  tears (and a SegV). kSecondGreater would mean that XLessThanY is no
//  longer strict weak ordering - it would be possible for the function to
//  return true for x<y and y<x and this breaks the sorting algorithm!


  if ( !x || !y ) MSG("Nav",Msg::kError) << "Passed null: " << x << " " << y << endl;
  if ( fgCurrent && fgCurrent->fOrderFuncs.size() ) {
    int size =  fgCurrent->fOrderFuncs.size();
    for (Int_t ifunc = 0; ifunc < size; ++ifunc ) {
      NavKeyFunc* keyFunc = fgCurrent->fOrderFuncs[ifunc];
      NavKey keyX = keyFunc->GetKey(x);
      NavKey keyY = keyFunc->GetKey(y);
      Int_t comp = keyX.CompareValue(keyY);
      if ( comp ) return (  comp < 0 ) ? kTRUE : kFALSE;
    }
  }

  if ( fgXLessThanYAmbResolve == kFirstGreater  ) return kFALSE; 
  return  ( x < y ) ? kTRUE : kFALSE;

}

/*    Template for New Member Function

//.....................................................................

NavSet:: {
//
//
//  Purpose:  
//
//  Arguments: 
//    xxxxxxxxx    in    yyyyyy
//
//  Return:    
//
//  Contact:   N. West
//
//  Specification:-
//  =============
//
//  o 

//  Program Notes:-
//  =============

//  None.


}

*/

---