
 // -*- C++ -*-


 namespace Hurricane {

 /*! \class        Slice
  *  \brief        Slice description (\b API)
  *
  *  \section      secSliceIntro  Introduction
  *
  *                The slices are objects which split the layout description of 
  *                a cell into horizontal slices grouping all objects located on 
  *                a given layer and storing them into a fast geometrical access 
  *                structure implemented by a quadtree. 
  * 
  * 
  *  \section      secSliceConstructionAndDestruction  Construction and destruction
  *
  *                The slices are fully managed by the cells : they are neither 
  *                created nor destroyed by the application programmer. 
  *
  *                Components are inserted in a slice (at their creation) and 
  *                removed from their slice (at their deletion). 
  *
  *                Empty slices being automatically deleted, you must never 
  *                store pointers to them. 
  * 
  * 
  *  \section      secSliceExample  Example
  *
  *                The following example shows how to visit all cell components 
  *                lying on a given basic layer and whose bounding box 
  *                intersects some rectangular area. 
\code
Cell* cell = ...; // we get the cell
 
BasicLayer* basicLayer = ...; // we get the basic layer
 
Box area = ...; // we define the rectangular area
 
forEach(Slice*, islice, cell->getSlices()) {
  if (islice->getLayer()->contains(basicLayer)) {
    forEach(Component*, icomponent, slice->getComponentsUnder(area)) {
      // ...
      // here we visit all requested components
      // ...
    }
  }
}
\endcode
  */


 /*! \function     Cell* Slice::getCell() const;
  *  \Return       the cell owning the slice. 
  */

 /*! \function     Layer* Slice::getLayer() const;
  *  \Return       the layer associated to the slice : all components lying in a 
  *                cell are perforce located on that layer. 
  */

 /*! \function     Box Slice::getBoundingBox() const;
  *  \Return       the bounding box of the slice, that is the smallest enclosing 
  *                rectangle of all its components. 
  */

 /*! \function     const Gos Slice::getGos() const;
  *  \Return       the collection of graphic objects lying on the slice. 
  */

 /*! \function     const Components Slice::getComponents() const;
  *  \Return       the collection of components lying on the slice. 
  */

 /*! \function     const Components Slice::getComponentsUnder(const Box& area) const;
  *  \Return       the collection of components of the slice whose bounding box 
  *                intersects the rectangular region defined by \c \<area\>. 
  */


 //! \name         Slice Collection
 //  \{

 /*! \typedef      Slices
  *                Collection representing a set of slices. 
  */

 /*! \typedef      SliceLocator
  *                Locator for traversing a collection of slices. 
  */

 /*! \typedef      SliceFilter
  *                Filter for selecting a subset of slices which match a given 
  *                criteria. 
  */

 /*! \def          for_each_slice(slice, slices)
  *                Macro for visiting the slices of a slice collection. 
  */

 //  \}

 }
