
 // -*- C++ -*-


 namespace Kite {

 /*! \class        TrackCost
  *  \brief        Insertion cost of a \TrackSegment in a \Track.
  *
  *
  *                The \TrackCost is not computed by itself. It has to be build by
  *                whoever has created it. For example Track::getOverlapCost().
  *
  *
  *  \section      secTrackCostOrdering  Sorting Track costs
  *
  *                The \TrackCost is composed of the following criterions :
  *                <ol>
  *                  <li>boolean \c _infinite : infinite.
  *                  <li>count \c _terminals : number of terminals.
  *                  <li>length \c _delta : overlap between requested interval and
  *                      \TrackSegment of the \Track.
  *                  <li>length \c _deltaPerpand : length of perpandicular wiring needed to
  *                      connect to this \Track.
  *                </ol>
  *                Criterions are listed above in decreasing lexicographical weigh order.
  *
  *                There is also special partial ordering functor : TrackCost::CompareByDelta.
  */

 /*! \function     TrackCost::TrackCost ( Track* track, const Interval& interval, size_t begin, size_t end );
  *  \param        track     The track on which the cost is performed.
  *  \param        interval  The interval for which we want a cost.
  *  \param        begin     The index of the first overlaping \TrackSegment in the \Track.
  *  \param        end       The index of the last overlaping \TrackSegment in the \Track.
  *
  *                Create a \TrackCost object. Constructor parameters cannot be changed
  *                after creation.
  *
  *  \remark       The cost is not computed by the constructor. It is computed afterward
  *                by any flavor of Track::getOverlapCost().
  */

 /*! \function     bool  TrackCost::isInfinite () const;
  *  \Return       The overlap include a \TrackSegment from a \GCellRoutingSet of
  *                higher priority, must'nt be overlaped.
  */

 /*! \function     bool  TrackCost::isHardOverlap () const;
  *  \Return       The overlaped \TrackSegment cannot be shrunk to create a sufficent
  *                free space. See the bound interval of \TrackSegmentCost.
  */

 /*! \function     bool  TrackCost::isOverlap () const;
  *  \Return       The overlaped \TrackSegment could be shrunk to create a suitable
  *                free space.
  */

 /*! \function     bool  TrackCost::isFree () const;
  *  \Return       There is enough free space to insert the \TrackSegment.
  */

 /*! \function     Track* TrackCost::getTrack () const;
  *  \Return       The associated \Track.
  */

 /*! \function     const Interval& TrackCost::getInterval () const;
  *  \Return       The interval for which we want to compute a cost.
  */

 /*! \function     size_t  TrackCost::getBegin () const;
  *  \Return       The index of the first overlaping \TrackSegment in \Track.
  */

 /*! \function     size_t  TrackCost::getEnd () const;
  *  \Return       The index of the last overlaping \TrackSegment in \Track.
  */

 /*! \function     unsigned int  TrackCost::getTerminals () const;
  *  \Return       The number of terminal in the interval, see TrackSegmentCost::getTerminals().
  */

 /*! \function     DbU::Unit  TrackCost::getDelta () const;
  *  \Return       The amount of overlaping between the interval and the \TrackSegments
  *                already in the \Track.
  */

 /*! \function     DbU::Unit  TrackCost::getDeltaPerpand () const;
  *  \Return       The amount of perpandicular wirelength needed to put the to be
  *                inserted \TrackSegment in this \Track.
  */

 /*! \function     void  TrackCost::setInfinite ();
  *                Raise the infinite flag.
  */

 /*! \function     void  TrackCost::setHardOverlap ();
  *                Raise the hard overlap flag.
  */

 /*! \function     void  TrackCost::setOverlap ();
  *                Raise the soft overlap flag.
  */

 /*! \function     void  TrackCost::incTerminals ( unsigned int number );
  *  \param        number  The number of terminal to adds.              
  */

 /*! \function     void  TrackCost::incDelta ( DbU::Unit delta );
  *  \param        delta  The amount of length to add to the overlap.              
  */

 /*! \function     void  TrackCost::incDeltaPerpand ( DbU::Unit delta );
  *  \param        delta  Increments the perpandicular delta.
  */

 /*! \function     bool  operator< ( const TrackCost& lhs, const TrackCost& rhs );
  *  \param        lhs  the left hand side operand.
  *  \param        rhs  the right hand side operand.
  *  \return       \true if <code>lhs < rhs</code>, see \ref secTrackCostOrdering.
  */


 /*! \class        TrackCost::CompareByDelta
  *  \brief        Partial compare function for \TrackCost.
  *
  *                Allow \TrackCost sorting on the \c _delta criterion alone.
  */

 }  // End of Kite namespace.
