diff --git a/kite/CMakeLists.txt b/kite/CMakeLists.txt
index 35f5786f..ca5985a6 100644
--- a/kite/CMakeLists.txt
+++ b/kite/CMakeLists.txt
@@ -1,3 +1,4 @@
+# -*- explicit-buffer-name: "CMakeLists.txt
- *
- * The perpandicular interval comes from perpandicular constraints on \TrackSegment
- * of the same \c Net. The left/right axis weights comes from requests of
- * other \c Nets.
- *
- * \image html RoutingEvent-1.png "RoutingEvent Intervals"
- * \image latex RoutingEvent-1.pdf "RoutingEvent Intervals" width=0.6\textwidth
- *
- * Example of perpandicular interval computation :
- *
- * \image html RoutingEvent-2.png "Perpandicular Interval"
- * \image latex RoutingEvent-2.pdf "Perpandicular Interval"
- *
- *
- * \section secRoutingEventRules Rules governing RoutingEvents
- *
- * \RoutingEvent respect the following rules:
- *
- *
- *
- * \remark Be very careful to distinguish between Session commands, which affects
- * \Track and \TrackSegment insertion/update/removal and schedule/re-schedule
- * events, which relates to the negociation algorithm.
- *
- * Re-ordering rules:
- *
- *
- *
- *
- * \section secRoutingEventCycle RoutingEvent life cycle
- *
- * As an active \RoutingEvent is associated with one and only one \TrackSegment
- * we can talk indeferently of \RoutingEvent lifecycle or \TrackSegment
- * lifecycle.
- *
- * Below is the ordered list of states that a \RoutingEvent could be in.
- * The order correspond to increasing level of slackening/freedom.
- * Transition between states occurs each time a maximum ripup is reached.
- *
- *
- *
- *
- *
- *
- *
- * \section secManageMaximumRipup Managing the maximum ripup case
- *
-\code
-bool State::manageMaximumRipup ()
-{
- bool success = false;
-
- if ( !_segment->isGlobal() ) {
- // Candidates Tracks (ignore optimal & perpandiculars).
- candidates = computeAllIntervals ();
- overlap = _segment->getInterval();
-
- for ( size_t i=0 ; i
- *
- * \b Id
- * \b Type
- * \b Local
- * \b Global
- * \b Action
- *
- *
- * \e 1
- * \c Minimize
- * \e yes
- * \e no
- * try to fit into a hole
- *
- *
- * \e 2
- * \c DogLeg
- * \e yes
- * \e no
- * Dogleg : analyse overlap and try to solve it by breaking (self)
- *
- *
- * \e 3
- * \c Desalignate
- * \e yes
- * \e yes
- * on a set of alignated \TrackSegment, suppress the
- * alignment constraints, thus making then independants
- *
- *
- *
- * \e 4
- * \c Slacken
- * \e yes
- * \e yes
- * if the target/source constraint is less than the
- * GCell, adds perpandicular straps to free the \TrackSegment.
- * This occurs to free from terminal constraints
- *
- *
- *
- * \e 5
- * \c ConflictSolve1
- * \e yes
- * \e yes
- * try to find in the history a reccurent dislodger,
- * and break (self) to accomodate it
- *
- *
- *
- * \e 6
- * \c ConflictSolve2
- * \e no
- * \e yes
- * try to find a Track on which we can dislodge
- * an other \TrackSegment
- *
- *
- *
- * \e 7
- * \c MoveUp
- * \e no
- * \e yes
- * try to go on upper layer.
- *
- *
- *
- * \e 8
- * \c Unimplemented
- * \e no
- * \e yes
- * we failed to place this \TrackSegment
- *
- *
- *
- *
- * \image html RoutingEvent-3.png "Set aside schematic"
- * \image latex RoutingEvent-3.pdf "Set aside schematic"
- *
- *
- * \section setDetructionStrategy Destruction Strategy
- *
- * \RoutingEvent are not destroyed as soon as they have been processed by
- * the scheduler. Instead, they are stored in the historical queue.
- * They are two reasons for that behavior :
- *
- *
- *
- * \important This is the history queue which is responsible for freeing all the
- * \RoutingEvent in his destructor.
- *
- *
- * \section secRoutingEventCase Routing Event actions
- *
- *
- *
+ * Cached key for stable sorting, see RoutingEvent::Key.
*/
- /*! \function bool RoutingEvent::isProcessed () const;
- * \return \true if this event has already been processed.
- *
- * \remark Note that inside a _setAside() a \RoutingEvent can be re-posted for
- * a given \TrackSegment which has been processed yet. This can lead
- * to two or more \RoutingEvent in the queue (as we cannot easily remove
- * a \RoutingEvent already in the queue). We need this new \RoutingEvent
- * because we want to reschedule with a new priority/slack.
- * As we cannot remove the previous \RoutingEvent, we mark it as
- * processed for it to be ignored by the scheduler.
+ //! \enum RoutingEvent::Mode
+ //! The working mode of the router, affect how events are to
+ //! be handled.
+
+ //! \var RoutingEvent::Negociate
+ //! This is the normal mode of operation, topological modifications
+ //! and ripup are enableds.
+
+ //! \var RoutingEvent::Pack
+ //! First post-processing step. For each segment, tries to find a
+ //! more compact position for a segment, but without riping any others.
+
+ //! \var RoutingEvent::Repair
+ //! Second post-processing step, try to find a suitable location for
+ //! a segment more aggressively.
+
+ //! \function unsigned int RoutingEvent::getStage ();
+ //! \sreturn The stage the router is in (see RoutingEvent::Mode).
+
+ //! \function size_t RoutingEvent::getAllocateds ();
+ //! \sreturn The number of RoutingEvent currently allocateds.
+
+ //! \function size_t RoutingEvent::getProcesseds ();
+ //! \sreturn The number of RoutingEvent that have been processeds since
+ //! the last call to RoutingEvent::resetProcesseds().
+
+ //! \function void RoutingEvent::resetProcesseds ();
+ //! \sreturn Reset the number of processeds events.
+
+ //! \function unsigned int RoutingEvent::setStage ( unsigned int mode );
+ //! Sets the router's stage (see RoutingEvent::Mode).
+
+ //! \function RoutingEvent* RoutingEvent::create ( TrackElement* element, unsigned int mode );
+ //! \param element The element for which to create the event.
+ //! \param mode The mode into which this event will be valid.
+ //!
+ //! RoutingEvent constructor.
+
+ //! \function RoutingEvent* RoutingEvent::clone () const;
+ //! \return A clone of the event.
+ //!
+ //! Cloning an event is slightly different from copying it (which is forbidden).
+ //! There can be multiple events for one \c element but only one must be
+ //! active at a time. This is a cheap way of implementing the rescheduling
+ //! mechanism. The original event remains the active one, but it's cloned
+ //! flag is raised. The cloned event is created inactive and with a null
+ //! \e eventLevel.
+
+ //! \function void RoutingEvent::destroy ();
+ //! The destructor.
+
+ //! \function bool RoutingEvent::isCloned () const;
+ //! \sreturn \true if this event has been cloned at least once.
+
+ //! \function bool RoutingEvent::isValid () const;
+ //! \sreturn \true if the cached informations from the \e element are valid
+ //! (i.e. the element has not been changed).
+
+ //! \function bool RoutingEvent::isUnimplemented () const;
+ //! \sreturn \true if the event has tried to use an unimplemented feature.
+
+ //! \function bool RoutingEvent::isProcessed () const;
+ //! \sreturn \true if the event has been processed.
+
+ //! \function bool RoutingEvent::isDisabled () const;
+ //! \sreturn \true if the event is \b not the active one. It should be discarted
+ //! by the algorithm.
+
+ //! \function bool RoutingEvent::isForcedToHint () const;
+ //! \sreturn \true the \e element must be placed exacltly on the given axis hint.
+
+ //! \function bool RoutingEvent::isRipedByLocal () const;
+ //! \sreturn \true the \e element (global) has been riped up to place a local one.
+
+ //! \function bool RoutingEvent::canMinimize () const;
+ //! \sreturn \true the \e element could still be minimized.
+
+ //! \function unsigned int RoutingEvent::getMode () const;
+ //! \sreturn the mode the event must be taken into account to.
+
+ //! \function unsigned int RoutingEvent::getState () const;
+ //! \sreturn the mode the router is currently in.
+
+ //! \function const Key& RoutingEvent::getKey () const;
+ //! \sreturn The \e key to use in map & queue for this event.
+
+ //! \function TrackElement* RoutingEvent::getSegment () const;
+ //! \sreturn The associated segment.
+
+ //! \function const vector
- *
- */
+ //! \function void RoutingEvent::process ( RoutingEventQueue& queue, RoutingEventHistory& history, RoutingEventLoop& loop );
+ //! \param queue The main event queue.
+ //! \param history The event's history list.
+ //! \param loop The loop detector.
+ //!
+ //! Process the event, that is:
+ //! - First, check if there is no looping, if any, do not process the
+ //! event but dicard it (marked as unimplemented).
+ //! - Second, attempt to place the associated segment. Pass it to the relevant
+ //! function, according to the router's mode (\c _processNegociate(),
+ //! \c processPack() or \c _processRepair() ).
+ //! Once processed, the event is added to both \c history (for the record)
+ //! and \c loop to check if we are not looping.
- /*! \function void RoutingEvent::setEventLevel ( unsigned int level );
- * \param level The new event level.
- *
- * \see getEventLevel().
- */
+ //! \function void RoutingEvent::setSegment ( TrackElement* element );
+ //! Change the associated \c segment. \red{Used only by TrackSegment::swapTrack().}
- /*! \function void RoutingEvent::process ( RoutingEventQueue& queue, RoutingEventHistory& history );
- * \param queue The event queue from the negociate algorithm.
- * \param history The event history.
- *
- * Perform all the operations shared by all \RoutingEvent classes then
- * calls the virtual _subProcess() functions.
- *
- * Shared operations are :
- *
- *
- * The results of the shared operation are passed to derived classes
- * trough the \c State internal structure.
- */
+ //! \function RoutingEvent* RoutingEvent::reschedule ( RoutingEventQueue& queue, unsigned int eventLevel);
+ //! \return The newly reinserted event. Depending on the cases it could be itself.
+ //!
+ //! Insert or reinsert an event in the scheduler. The \c eventLevel parameter only
+ //! allows to increase the level (if it is less than the current level of the
+ //! event, it will be ignored).
+ //!
+ //! Cloning Management. As an event could be cloned, if we try to re-insert
+ //! a disabled original, we must first lookup the currently cloned active event.
+ //! This is done through the associated \c segment which must always be associated
+ //! with the active event (if any).
+ //!
+ //! Unimplemented Protection. If the unimplemented flag is set the reschedule
+ //! is cancelled (\c NULL is returned).
+ //!
+ //! Unprocessed Event. The event is still in queue, waiting to be
+ //! processed, then just repush it in the queue with it's new level.
+ //!
+ //! Processed Event. Clone the already processed one, activate it
+ //! and push it on the queue.
+ //!
+ //! Router's Mode. The mode is also updated.
- /* \function bool RoutingEvent::_setAside ( Track* track, size_t begin, size_t end, Net* net, Interval interval, RoutingEventQueue& queue );
- * \param track The track in wich to make free space.
- * \param begin The index of the first overlaping TrackSegment.
- * \param end The index of the last overlaping TrackSegment.
- * \param net The net for which we want to insert a TrackSegment.
- * \param interval The interval which must be made empty.
- * \param queue The queue of RoutingEvent.
- *
- * Manage the case of soft overlap. Create or enlarge a free space
- * in \c track so it can contain the requested \interval. [begin:end]
defines
- * the range of indexes of overlaping \TrackSegment in \c track.
- * Displace TrackSegment that are perpandicular to those overlaping,
- * remove them from their \c Track if needed and issue an associated \RoutingEvent
- * with an updated bound constraint. Note that the overlaping \TrackSegment
- * themselves are not removed from the \c track.
- *
- * A note on implementation :
- *
- *
- */
+ //! \function void RoutingEvent::setMode ( unsigned int mode );
+ //! Set the mode in which the event must be processed (see RoutingEvent::Mode).
- /* \function void RoutingEvent::_ripup ( Track* track, Net* net, Interval interval, size_t begin, size_t end, RoutingEventQueue& queue );
- * \param track The track in wich to make free space.
- * \param net The net for which we want to insert a TrackSegment.
- * \param interval The interval which must be made empty.
- * \param begin The index of the first overlaping TrackSegment.
- * \param end The index of the last overlaping TrackSegment.
- * \param queue The queue of RoutingEvent.
- *
- * Manage the case of hard overlap, that is bluntly remove
- * any \TrackSegment overlaping \interval. Issue both a remove event
- * (to \c Session) and a \RoutingEvent to re-process the dislodged
- * \TrackSegment.
- */
+ //! \function void RoutingEvent::setState ( unsigned int state );
+ //! Proxy mutator for DataNegociate::setState().
- } // End of Kite namespace.
+ //! \function void RoutingEvent::setAxisHintFromParent ();
+ //! Sets the axis hint from it's parent segment. The parentage is found
+ //! through the TrackSegment parentage.
+
+ //! \function void RoutingEvent::incInsertState ();
+ //! Increment the insertion state.
+ //!
+ //! \sa RoutingEvent::getInsertState().
+
+ //! \function void RoutingEvent::resetInsertState ();
+ //! Reset the insertion state.
+ //!
+ //! \sa RoutingEvent::getInsertState().
+
+ //! \function void RoutingEvent::setEventLevel ( unsigned int level );
+ //! Set the event level (user-controlled re-ordering).
+
+ }
diff --git a/kite/doc/Session.dox b/kite/doc/Session.dox
index 45ca9041..dc6dd463 100644
--- a/kite/doc/Session.dox
+++ b/kite/doc/Session.dox
@@ -1,133 +1,163 @@
-
- // -*- C++ -*-
+ // -*- mode: C++; explicit-buffer-name: "Session.dox
- *
+ * - Modifications events are recorded (queued) into the Session.
+ * At this step, no modification are actually done, the
+ * data-base retains it's previous state and coherency.
+ * - The \c revalidate() procedure is called (or the Session
+ * is closed), then all the modification events are applied.
+ * The data-base is in now in it's new state.
*
*
* \section secKiteSessionRevalidate The Revalidate Algorithm.
*
* Revalidation steps :
- *
- *
- */
-
-
- /*! \name Accessors
- */
- // \{
-
- /*! \function static Session* Session::get ();
- * \Return The currently opened session, \c NULL if no session has
- * been opened.
- */
-
- /*! \function static KiteEngine* Session::getKiteEngine ();
- * \Return The Kite ToolEngine associated to the current update
- * session.
- */
-
- // \}
-
-
- /*! \name Miscellaneous
- */
- // \{
-
- /*! \function bool Session::isEmpty ();
- * Ensure that the Session is empty and can be closed (deleted)
- * safely.
- */
-
- /*! \function static Session* Session::open ( KiteEngine* kite );
- * \param kite A Kite ToolEngine on which to work.
- * \return A new Kite update Session.
+ * - Process all remove events. detach TrackSegment from
+ * their Track, but do not remove the pointer from the
+ * internal \vector.
+ * - Pack all Track in which removal have took place.
+ * - Process all insert events. This is the time TrackSegment
+ * are moved into their new Track (physical displacement).
+ * It is at this point that the invalidation of both AutoSegment
+ * and TrackSEgment is done.
+ * - Call the Katabatic::Session::revalidate() method which
+ * will recompute the correct contact extensions and topologies.
+ * \e After this step the Katabatic data-base is up to date,
+ * but \e not the Kite one. AutoSEgment are revalidated.
+ * - Recompute the canonical position of source and target
+ * of all invalidateds TrackSegment (take account of
+ * extention modifications). The set of invalidated TrackSegment
+ * is computed from the revalidated AutoSegment, that is
+ * AutoSegment that are canonical.
+ * - Perform a sort() on all Track that have been modifieds.
*
- * Open a new Kite update Session on the \c kite \c ToolEngine.
- * At this point only one session can be opened at a time. Attempt
- * to open a second one will result in an exception.
- */
-
- // \}
-
-
- /*! \name Event Scheduling
- */
- // \{
-
- /* \function void Session::addInvalidated ( TrackSegment* segment );
- * \param segment An AutoSegment that has been moved.
+ * Note: We cannot use the Observer mechanism to automatically
+ * update TrackSegment from an AutoSegment, because we must wait for all
+ * AutoSegments (canonical or not) involved into the TrackSegment to be
+ * up to date before we can update it.
*
- * add \e segment to the \vector of TrackSegment for which we
- * have to recompute the canonical size (i.e. extentions may
- * have moved).
+ * Note: Have to talk about the special case when new canonical
+ * AutoSegment appears after dogleg creation.
+ *
+ *
+ * \section secKiteSessionLookup The Lookup Mechanism
+ *
+ * There are two lookup mechanisms:
+ * - From a Hurricane::Segment, we uses the Katabatic segment lookup
+ * table (slow, stored in a \c map<>).
+ * - From a Katabatic::AutoSegment, we uses the Observer, it's owner
+ * is the TrackSegment (fast).
*/
- /*! \function void Session::addInsertEvent ( TrackSegment* segment, Track* track );
- * \param segment An AutoSegment to insert in a Track.
- * \param track The Track into which the \e segment will be inserted.
- *
- * Schedule the insertion of \e segment into Track \e track.
- * The \e segment must not already be part of a Track.
- */
+ //! \function Session* Session::open ( KiteEngine* kite );
+ //! \param kite A Kite ToolEngine on which to work.
+ //! \return A new Kite update Session.
+ //!
+ //! Open a new Kite update Session on the \c kite \c ToolEngine.
+ //! At this point only one session can be opened at a time. Attempt
+ //! to open a second one will result in an exception.
- /*! \function void Session::addRemoveEvent ( TrackSegment* segment );
- * \param segment An AutoSegment to remove from a Track.
- *
- * Schedule the removal of \e segment from Track \e track.
- */
+ //! \function Session* Session::get ( const char* message=NULL );
+ //! \sreturn The currently opened session, \c NULL if no session has
+ //! been opened.
- /*! \function void Session::addMoveEvent ( TrackSegment* segment, Track* track );
- * \param segment An AutoSegment to move into a new Track.
- * \param track The Track into which the \e segment will be moved.
- *
- * Schedule the displacement of \e segment into Track \e track.
- */
+ //! \function Katabatic::Session* Session::base ();
+ //! \sreturn The Session, casted as it's base object.
- /*! \function void Session::addSortEvent ( Track* track, bool forced=false );
- * \param track The Track to update.
- * \param forced Force the invalidation of the \Track.
- *
- * Schedule the update of Track \e track. If the \Track has not been
- * invalidated, no actual sort will takes place. To force a sort
- * (manually invalidating the \Track), sets \b forced to \true.
- *
- * \see Track::pack() & Track::sort().
- */
+ //! \function bool Session::isEmpty ();
+ //! Ensure that the Session is empty and can be closed (deleted)
+ //! safely.
+
+ //! \function Configuration* Session::getConfiguration ();
+ //! \sreturn The Kite Configuration of the Router (proxy helper).
+
+ //! \function Net* Session::getBlockageNet ();
+ //! \sreturn The net used to create blockage components (proxy helper).
+
+ //! \function KiteEngine* Session::getKiteEngine ();
+ //! \sreturn The Kite ToolEngine associated to the current update
+ //! session (proxy helper).
+
+ //! \function NegociateWindow* Session::getNegociateWindow ();
+ //! \sreturn The current NegociateWindow (proxy helper).
+
+ //! \function Katabatic::GCell* Session::getGCellUnder ( DbU::Unit x, DbU::Unit y );
+ //! \sreturn The GCell under \c (x,y) (proxy helper, see Katabatic::GCellGrid::getGCell()).
+
+ //! \function void Session::addInsertEvent ( TrackElement* segment, Track* track );
+ //! \param segment An AutoSegment to insert in a Track.
+ //! \param track The Track into which the \e segment will be inserted.
+ //!
+ //! Schedule the insertion of \e segment into Track \e track.
+ //! The \e segment must not already be part of a Track.
+
+ //! \function void Session::addRemoveEvent ( TrackElement* segment );
+ //! \param segment A TrackSegment to remove from a Track.
+ //!
+ //! Schedule the removal of \e segment from Track \e track.
+
+ //! \function void Session::addMoveEvent ( TrackElement* segment, Track* track );
+ //! \param segment An AutoSegment to move into a new Track.
+ //! \param track The Track into which the \e segment will be moved.
+ //!
+ //! Schedule the displacement of \e segment into Track \e track.
+
+ //! \function void Session::addSortEvent ( Track* track, bool forced=false );
+ //! \param track The Track to update.
+ //! \param forced Force the invalidation of the \Track.
+ //!
+ //! Schedule the update of Track \e track. If the \Track has not been
+ //! invalidated, no actual sort will takes place. To force a sort
+ //! (manually invalidating the \Track), sets \b forced to \true.
+ //!
+ //! \sa Track::pack() & Track::sort().
+
+ //! \function void Session::revalidate ();
+ //! Applies all the requested modifications, but keeping the session
+ //! opened.
+
+ //! \function TrackElement* Session::lookup ( Segment* segment );
+ //! \sreturn the TrackElement associated to \c segment.
+
+ //! \function TrackElement* Session::lookup ( AutoSegment* segment );
+ //! \sreturn the TrackElement associated to \c segment.
- // \}
}
diff --git a/kite/doc/Track.dox b/kite/doc/Track.dox
index 3422d6ee..a7b3f156 100644
--- a/kite/doc/Track.dox
+++ b/kite/doc/Track.dox
@@ -7,391 +7,481 @@
/*! \class Track
* \brief Structure managing one routing track.
*
+ * \section secTrackPurpose Track Purpose
+ *
+ * We use an array of regularly spaced Track as a geometrical
+ * fast access structure. It allows to know whether an area is used or
+ * not. The whole area may be seen as a set of adjoining tiles of fixed
+ * \e width but variable \e length.
+ *
+ * The figure (1.b) show, for an horizontal, track the relation
+ * between y,min,max
and the occupied area of the plane.
+ * \c min and \c max must take into account segment extensions (\c e) and
+ * the minimal distance between two rectangles (\c MD) of the same layer.
+ * We assume that the width of the segment, augmented of all it's
+ * contraints is no greater than \c TS (in fact it's how \c TS must be
+ * calculated).
+ *
+ * For the whole track array, see RoutingPlane.
+ *
+ * \image html Track-0.png "Fig 1: Track Area"
+ *
+ *
* \section secTrackImplementation Track Implementation
*
- * Basically a Track is a sorted vector of TrackSegment, TrackSegment
- * beeing a decoration of the Katabatic::AutoSegment. Managment rules :
- *
- *
+ * A Track is implemented with a sorted vector of TrackElement.
+ * TrackElements from differents nets must not overlap.
+ * The sorting order is defined as follow:
+ * - TrackElements are sorted by increasing source (\e min)
+ * positions.
+ * - In case of overlap (i.e. belongs to the same net), if
+ * they share the same source position, then they are sorted
+ * by \e decreasing length. This way, the longest one will be
+ * the first encountered when walking through the Track in
+ * increasing index order.
*
- * \image html Track-1.png "Track Structure"
+ * Figure 2.b shows the details of the Track [1] of
+ * figure 1.a. Net \b \
- *
- */
-
- /*! \function TrackSegment* Track::getSegment ( DbU::Unit position ) const;
- * \param position The position where to search.
- * \return The TrackSegment whose starting point is immediatly inferior to \e position.
- */
-
- /*! \function size_t Track::find ( const TrackSegment* segment ) const;
- * \Return the \e index of \e segment inside the Track. If the \e segment do
- * not belongs to the Track, return Track::NPOS.
- */
-
- /*! \function void Track::getIBounds ( DbU::Unit position, size_t& begin, size_t& end, unsigned int& state ) const;
- * \param position The position where to search.
- * \param begin Index of the starting bound.
- * \param end Index of the ending bound.
- * \param state how to use the returned \e indexes.
- * \return The TrackSegment index around \e position.
+ * It is at that step that the TrackElement axis is actually updated
+ * through a call to TrackElement::setAxis().
+ *
+ * Revalidation Sequence
*
- * The relation between the returned \e index and the position is
- * given through the \e state parameter.
+ * After a Track has been modificated either the Track element vector or
+ * the MarkerElement vector (or both) has been invalidateds. Revalidation
+ * take place in three steps:
+ * - Track::doRemoval(), remove all TrackElement marked for removal.
+ * - Track::insert(), insert the TrackElement into their new Track.
+ * - Track::doReorder(), sort the TrackElement of the vector, that is, put the
+ * newly inserted elements at their right place.
*
- * \note It uses the \lower_bound \STL function.
- */
-
- /*! \function DbU::Unit Track::getSourcePosition ( size_t index ) const;
- * \Return The canonical source position of TrackSegment at index \e index.
- * If \e index is equal to Track::NPOS, returns zero.
- */
-
- /*! \function DbU::Unit Track::getSourcePosition ( vector
- *
+ * Returns the complete interval of a set of overlapping TrackElement from
+ * the same net.
*/
- /*! \function void Track::checkOverlap () const;
- * \return the number of overlaping TrackSegment.
- *
- * Perform the following checks :
- *
- *
- */
+ //! \enum Track::IndexState
+ //! Indicates how to compute the bounds of the interval enclosing
+ //! a given \c position on track axis.
+ //!
+ //! \note According to \e position, the interval can be a free interval
+ //! or a used interval.
- /*! \function void Track::getOverlapBounds ( Interval interval, size_t& begin, size_t& end ) const;
- * \param interval the overlaping interval.
- * \param begin where to store the starting bound.
- * \param end where to store the ending bound.
- *
- * find the range of TrackSegment intersecting \e interval.
- * Note that when the \e interval lower bound crosses a set of
- * overlaping intervals from the same \Net, the interval at
- * \e begin will crosses the lower bound but some following
- * of the same \Net may not.
- */
+ //! \var Track::BeginIsTrackMin
+ //! (implies \c begin=0) there is no TrackElement \e before \c position
- /*! \function DbU::Unit Track::getOverlapCost ( Interval interval, Net* net, size_t begin, size_t end ) const;
- * \param interval the overlaping interval.
- * \param net a Net to ignore (null cost).
- * \param begin the starting bound.
- * \param end the ending bound.
- * \return The cost of the overlap.
- *
- * compute the cost of the overlap of \e interval with the range
- * \c [begin,end] of TrackSegment. Any TrackSegment belonging to
- * \e net will be ignored.
- */
+ //! \var Track::BeginIsSegmentMin
+ //! The \c begin segment starts \e before \c position and ends \e after.
- /*! \function DbU::Unit Track::getOverlapCost ( Interval interval, Net* net ) const;
- * \param interval the overlaping interval.
- * \param net a Net to ignore (null cost).
- *
- * compute the overlap of \e interval with TrackSegment from
- * the current Track, ignoring thoses belonging to \e net.
- */
+ //! \var Track::BeginIsSegmentMax
+ //! The \c begin segment starts and ends \e before \c position.
- // \}
+ //! \var Track::EndIsTrackMax
+ //! There is no TrackElement \e after \c position.
+ //! \var Track::EndIsSegmentMin
+ //! The \c begin segment starts \e before \c position.
- /*! \name Updators
- */
- // \{
+ //! \var Track::EndIsNextSegmentMin
+ //! The \c begin segment starts and ends \e before \c position. So the maximum
+ //! is given by the \c minimum of the \e next TrackElement.
- /*! \function void Track::insert ( TrackSegment* segment );
- * adds \e segment to the Track. Must only be used inside a
- * TrackSession.
- *
- * \see TrackSession.
- */
+ //! \var Track::EndIsSegmentMax
+ //! The \c begin segment starts \e before \c position and ends \e after.
- /*! \function size_t Track::pack ();
- * \Return The number of removeds TrackSegment.
- *
- * Suppress all the TrackSegment that have been withdraw from the
- * Track. TrackSegment must be withdraw trough the TrackSegment::detach()
- * method which sets their owning Track to \NULL (the removal criterion).
- */
+ //! \var Track::BeforeFirstElement
+ //! the \c position is before the first TrackElement.
- /*! \function void Track::sort ();
- *
- * sort the the vector. Must be called \e after the Pack() method,
- * so no detached TrackSegment are presents.
- */
+ //! \var Track::InsideElement
+ //! the \c position is inside a TrackElement.
- // \}
+ //! \var Track::OutsideElement
+ //! the \c position is in free zone between two TrackElements.
+
+ //! \var Track::AfterLastElement
+ //! the position is after the end of the last element.
+
+ //! \var Track::EmptyTrack
+ //! the track is still empty.
+
+ //! \var Track::BeginMask
+ //! To extract the \e begin part from a combination of flags.
+
+ //! \var Track::EndMask
+ //! To extract the \e end part from a combination of flags.
+
+ //! \var Track::npos;
+ //! A special index value (greatest integer) meaning that
+ //! an index is invalid.
+
+ //! \function bool Track::isHorizontal () const;
+ //! \sreturn \true if the Track in horizontal direction.
+
+ //! \function bool Track::isVertical () const;
+ //! \sreturn \true if the Track in vertical direction.
+
+ //! \function bool Track::isLocalAssigned () const;
+ //! \sreturn \true is the Track should be preferentially used for local routing.
+
+ //! \function RoutingPlane* Track::getRoutingPlane () const;
+ //! \sreturn The RoutingPlane owning this Track.
+
+ //! \function KiteEngine* Track::getKiteEngine () const;
+ //! \sreturn The KiteEngine owning this Track.
+
+ //! \function unsigned int Track::getDirection () const;
+ //! \sreturn The direction of the Track, either Katabatic::KbHorizontal or
+ //! Katabatic::KbVertical.
+
+ //! \function RoutingPlane* Track::getIndex () const;
+ //! \sreturn The index of this Track in the RoutingPlane Track vector.
+
+ //! \function unsigned int Track::getDepth () const;
+ //! \sreturn The depth (as given by the RoutingGauge) of the Track's layer.
+
+ //! \function Layer* Track::getLayer () const;
+ //! \sreturn The \Layer of the Track.
+
+ //! \function Layer* Track::getBlockageLayer () const;
+ //! \sreturn The associated blockage \Layer to the Track's layer.
+
+ //! \function DbU::Unit Track::getAxis () const;
+ //! \sreturn The Axis of the Track.
+
+ //! \function DbU::Unit Track::getMin () const;
+ //! \sreturn The minimal allowed coordinate of the Track.
+
+ //! \function DbU::Unit Track::getMax () const;
+ //! \sreturn The maximal allowed coordinate of the Track.
+
+ //! \function Track* Track::getNextTrack () const;
+ //! \sreturn The next Track in the \RoutingPlane vector. That is the
+ //! one with the axis immediatly superior.
+
+ //! \function Track* Track::getPreviousTrack () const;
+ //! \sreturn The previous Track in the \RoutingPlane vector. That is the
+ //! one with the axis immediatly inferior.
+
+ //! \function size_t Track::getSize () const;
+ //! \sreturn The total number of TrackSegment in the Track.
+
+ //! \function Point Track::getPosition ( DbU::Unit position ) const;
+ //! \sreturn the point at \c (position,getAxis()) for horizontal Track
+ //! at or \c (getAxis(),position) for vertical Track.
+
+ //! \function TrackSegment* Track::getSegment ( size_t index ) const;
+ //! \param index The index of the TrackSegment.
+ //! \return The TrackSegment at \e index. The result will be \NULL in the
+ //! follwing cases :
+ //! - \e index is outside the sorted zone.
+ //! - \e index points to a hole in the Track.
+ //! - \e index is equal to Track::npos.
+
+ //! \function TrackSegment* Track::getSegment ( DbU::Unit position ) const;
+ //! \param position The position where to search.
+ //! \return The TrackSegment whose starting point is immediatly inferior to \e position.
+
+ //! \function TrackSegment* Track::getNext ( size_t& index, Net* net ) const;
+ //! \param index Index of the starting TrackSegment.
+ //! \param net A \Net to ignore.
+ //! \return The next TrackSegment (\NULL if not found).
+ //!
+ //! Find, starting from TrackSegment at \e index the next TrackSegment
+ //! ignoring TrackSegment from \e net. \e index is modified to point
+ //! on the returned TrackSegment. If there's no next TrackSegment (\NULL)
+ //! then index is set to Track::npos.
+
+ //! \function TrackSegment* Track::getPrevious ( size_t& index, Net* net ) const;
+ //! \param index Index of the starting TrackSegment.
+ //! \param net A \Net to ignore.
+ //! \return The previous TrackSegment (\NULL if not found).
+ //!
+ //! find, starting from TrackSegment at \e index the previous TrackSegment
+ //! ignoring TrackSegment from \e net. \e index is modified to point
+ //! on the returned TrackSegment. If there's no previous TrackSegment (\NULL)
+ //! then index is set to Track::npos.
+
+ //! \function TrackSegment* Track::getNextFixed ( size_t& index ) const;
+ //! \param index Index of the starting TrackSegment.
+ //! \return The first previous \e Fixed TrackSegment.
+ //!
+ //! find, starting from TrackSegment at \e index the first previous
+ //! with a \e Fixed attribute set. \e index is modified to point on the
+ //! returned TrackSegment. If there's no previous TrackSegment (\NULL)
+ //! then index is set to Track::npos.
+
+ //! \function size_t Track::find ( const TrackElement* element ) const;
+ //! \sreturn the \e index of \e element inside the Track. If the \e element do
+ //! not belongs to the Track, return Track::npos.
+
+ //! \function DbU::Unit Track::getSourcePosition ( size_t index ) const;
+ //! \sreturn The source position of TrackSegment at index \e index.
+ //! If \e index is equal to Track::npos, returns zero.
+
+ //! \function DbU::Unit Track::getSourcePosition ( vector[begin,end]
interval, expand the
+ //! interval to encompass all free space or segments belonging to \c net.
+ //! \c state may be used to compute the interval bounds from \c begin
+ //! and \c end instead of directly using the returned \c interval.
+ //!
+ //! \note \c ]begin,end[ must define a free interval between two TrackSegment.
+
+ //! \function void Track::getBeginIndex ( DbU::Unit position, size_t& begin, unsigned int& state ) const;
+ //! \param position The position where to search.
+ //! \param begin Index of the immediatly inferior TrackElement.
+ //! \param state how to interpret the returned \c begin.
+ //!
+ //! Return in \c begin the index of the TrackElement whose minimum is immediately
+ //! below the requested \c position on the Track axis. The second returned
+ //! parameter \c state is a set of flags to tell how the \c begin index
+ //! has to be interpreted.
+ //!
+ //! Flags for the \c state are:
+ //! - Track::BeginIsTrackMin : (implies \c begin=0) there is no TrackElement
+ //! \e before \c position.
+ //! - Track::EndIsSegmentMin : The \c begin segment starts \e before \c position.
+ //! - Track::BeginIsSegmentMin : The \c begin segment starts \e before \c position
+ //! and ends \e after.
+ //! - Track::EndIsSegmentMax : The \c begin segment starts \e before \c position
+ //! and ends \e after.
+ //! - Track::BeginIsSegmentMax : The \c begin segment starts and ends \e before
+ //! \c position.
+ //! - Track::EndIsNextSegmentMin : The \c begin segment starts and ends \e before
+ //! \c position. So the maximum is given by the \c minimum of the \e next
+ //! TrackElement.
+ //! - Track::EndIsTrackMax : There is no TrackElement \e after \c position.
+ //!
+ //! Based on the previous flags, we build the \c state parameter:
+ //! - Track::BeforeFirstElement : the \c position is before the first TrackElement.
+ //! - Track::InsideElement : the \c position is inside a TrackElement.
+ //! - Track::OutsideElement : the \c position is in free zone between two
+ //! TrackElements.
+ //! - Track::AfterLastElement : the position is after the end of the last
+ //! element.
+ //! - Track::EmptyTrack : the track is still empty.
+ //!
+ //! To separate flags relevant to \e begin and \e end informations, two masks
+ //! are provideds:
+ //! - Track::BeginMask
+ //! - Track::EndMask
+ //!
+ //! \image html TrackBeginIndex-1.png "Fig 3: Track::getBeginIndex()"
+ //!
+ //! Reminder for myself:
+ //! The Track::getBeginIndex() function relies on the \STL \lower_bound
+ //! function. \c lower_bound() finds the TrackElement immediately \e superior
+ //! to \c position (shown on Figure 3 by the \c LB label in white on black).
+ //!
+ //! The relation between the returned \c begin index and the position is
+ //! given through the \c state parameter.
+
+ //! \function void Track::getOverlapBounds ( Interval interval, size_t& begin, size_t& end ) const;
+ //! \param interval the overlaping interval.
+ //! \param begin where to store the starting bound.
+ //! \param end where to store the ending bound.
+ //!
+ //! find the range of TrackSegment intersecting \e interval.
+ //! Note that when the \e interval lower bound crosses a set of
+ //! overlaping intervals from the same \Net, the interval at
+ //! \e begin will crosses the lower bound but some following
+ //! of the same \Net may not.
+
+ //! \function TrackCost Track::getOverlapCost ( Interval interval, Net* net, size_t begin, size_t end, unsigned int flags ) const;
+ //! \param interval the overlaping interval.
+ //! \param net a Net to ignore (null cost).
+ //! \param begin the starting bound.
+ //! \param end the ending bound.
+ //! \param flags passed to the overlap cost function.
+ //! \return The cost of the overlap.
+ //!
+ //! Compute the cost of the overlap of \e interval with the range
+ //! \c [begin,end] of TrackSegment. Any TrackSegment belonging to
+ //! \e net will be ignored.
+
+ //! \function TrackCost Track::getOverlapCost ( Interval interval, Net* net, unsigned int flags ) const;
+ //! \param interval the overlaping interval.
+ //! \param net a Net to ignore (null cost).
+ //! \param flags passed to the overlap cost function.
+ //!
+ //! Compute the overlap cost of \e interval with TrackSegment from
+ //! the current Track, ignoring thoses belonging to \e net.
+
+ //! \function TrackCost Track::getOverlapCost ( TrackElement* segment, unsigned int flags ) const;
+ //! \param segment under which to compute overlap cost.
+ //! \param flags passed to the overlap cost function.
+ //!
+ //! Compute the overlap cost of \c segment with TrackSegment from
+ //! the current Track (interval and net are deduced from \c segment).
+
+ //! \function void Track::getTerminalWeight ( Interval interval, Net* net, size_t& count, unsigned int& weight ) const;
+ //! \param interval under which to compute terminal weight.
+ //! \param net a net to be ignored.
+ //! \param count incremented of the number of track markers under the
+ //! \c interval.
+ //! \param weight incremented of the sum of the weight of the track markers
+ //! under the \c interval.
+ //!
+ //! Compute and return the sum of the weight of the track markers (see TrackMarker)
+ //! under \c interval ignoring \c net (that is, \e for \c net).
+ //!
+ //! \remark The referenced variables \c count and \c weight are not reset to
+ //! zero by this function. It is of the caller's responsability.
+
+ //! \function bool Track::check ( unsigned int& overlaps, const char* message=NULL ) const;
+ //! \param overlaps The number of overlaping segments.
+ //! \param message An iformative message, only printed if an error occurs.
+ //! \return \true if the Track contains no incoherencies.
+ //!
+ //! Perform a complete Track check. Looks for the following incoherencies :
+ //! - TrackSegment do not refers this Track.
+ //! - TrackSegment is detached (TrackSegment::getTrack() is \NULL).
+ //! - TrackSegment is hollow, this one is very unlikely as hollow
+ //! TrackSegment are only created for the \lower_bound.
+ //! - \NULL pointers (should never occurs, nevertheless...)
+ //! - Two consecutive TrackSegment from different \Net must not
+ //! overlap.
+ //! - For TrackSegment starting from the same position, the
+ //! longuest must be first.
+
+ //! \function void Track::invalidate ();
+ //! Inconditionnaly invalidate the Track, regardless if it has been
+ //! modificated. The Track will be forced to be revalidated on closure
+ //! of the current session.
+
+ //! \function void Track::insert ( TrackElement* segment );
+ //! Adds \e segment to the Track. Must only be used inside a
+ //! Session. They must appears \e after Track::doRemoval()
+ //! and \e before Track::doReorder().
+ //!
+ //! \sa Kite::Session.
+
+ //! \function void Track::insert ( TrackMarker* marker );
+ //! Adds \e marker to the Track. Must only be used inside a
+ //! Session.
+ //!
+ //! \sa Kite::Session.
+
+ //! \function void Track::setSegment ( TrackElement* element, size_t index );
+ //! Directly affect the Track entry at position \c index to
+ //! \c element (use with great care).
+ //!
+ //! \sa Kite::Session.
+
+ //! \function size_t Track::doRemoval ();
+ //! \sreturn The number of removeds TrackSegment.
+ //!
+ //! Suppress all the TrackSegment that have been withdraw from the
+ //! Track. TrackSegment must be withdraw trough the TrackSegment::detach()
+ //! method which sets their owning Track to \NULL (the removal criterion).
+ //! It uses the \STL \e remove_if algorithm that put all the to be removed
+ //! elements at the end of the vector.
+ //!
+ //! \sa Kite::Session.
+
+ //! \function void Track::doReorder ();
+ //!
+ //! (Re)sort the TrackElement of the vector. Must be called \e after:
+ //! - Track::doRemoval() so no detached TrackSegment are presents.
+ //! - All calls to Track::insert(), as the newly inserted elements
+ //! are put at the back of the vector.
+ //!
+ //! \sa Kite::Session.
}
diff --git a/kite/doc/TrackSegment.dox b/kite/doc/TrackSegment.dox
index cb68db85..eb8e54ca 100644
--- a/kite/doc/TrackSegment.dox
+++ b/kite/doc/TrackSegment.dox
@@ -1,18 +1,13 @@
-
// -*- C++ -*-
namespace Kite {
- /*! \typedef SegmentOverlapCostCB
- * Prototype of overlap cost callback functions.
- *
- * \see TrackSegment::setOverlapCostCB(), TrackSegment::getOverlapCost().
- */
-
/*! \class TrackSegment
* \brief Derived Katabatic::AutoSegment for the router.
*
+ * \image html TrackSegment-10.png "Fig 1: TrackSegment Context"
+ *
* We create one TrackSegment per aligned Katabatic::AutoSegment set,
* the TrackSegment is associated to the canonical one of the set.
*
@@ -21,150 +16,114 @@
* The drawback beeing that whenever one segment from the aligned
* set has it's extention modified, the full extention must be
* recomputed.
- */
-
-
- /*! \name Constructors & Destructors
- */
- // \{
-
- /*! \function static TrackSegment* TrackSegment::create ( AutoSegment* segment, Track* track, bool& created );
- * \param segment The Katabatic AutoSegment to decorate.
- * \param track A Track into which insert the TrackSegment (may be \NULL).
- * \param created This flag is sets is a new TrackSegment has be created.
- * \return A TrackSegment wrapped around an AutoSegment.
*
- * Constructor mainly used at loading time to decorate the Katabatic
- * data-base with the router attributes.
- */
-
- // \}
-
-
- /*! \name Predicates
- */
- // \{
-
- /*! \function bool TrackSegment::isLocked () const;
- * \Return \True if the TrackSegment is locked (cannot be deleted from the
- * Track).
- */
-
- // \}
-
-
- /*! \name Callback modifier
- */
- // \{
-
- /*! \function SegmentOverlapCostCB* TrackSegment::setOverlapCostCB ( SegmentOverlapCostCB* cb );
- * \param cb the new overlap cost callback.
- * \return the previous overlap cost callback.
*
- * sets the overlap callback.
- */
-
- // \}
-
-
- /*! \name Accessors
- */
- // \{
-
- /*! \function Track* TrackSegment::getTrack () const;
- * \Return The Track in which this TrackSegment is inserted (can be \NULL).
- */
-
- /*! \function size_t TrackSegment::getIndex () const;
- * \Return Index of the TrackSegment inside the Track's vector. set to
- * Track::NPOS if not inserted in any Track.
- */
-
- /*! \function unsigned long TrackSegment::getArea () const;
- * \Return The priority value used for TrackSegment sorting. Currently,
- * the slack of the AutoSegment.
- */
-
- /*! \function TrackSegment* TrackSegment::getNext () const;
- * \Return The next TrackSegment in the Track (can be \NULL).
+ * \section secTSLazyRevalidate Lazy Revalidate
*
- * \see Track::getNext().
- */
-
- /*! \function TrackSegment* TrackSegment::getPrevious () const;
- * \Return The previous TrackSegment in the Track (can be \NULL).
+ * When the TrackSegment::revalidate() method is called, it only update
+ * the cached size of the segment (from the AutoSegment set of aligneds)
+ * and the track into which it may be inserted.
*
- * \see Track::getPrevious().
- */
-
- /*! \function Interval TrackSegment::getFreeInterval () const;
- * \Return The free interval around this TrackSegment in the Track.
- */
-
- /*! \function DbU::Unit TrackSegment::getSourceCanonical () const;
- * \Return The leftmost position of the associated aligned segment set.
- */
-
- /*! \function DbU::Unit TrackSegment::getTargetCanonical () const;
- * \Return The rightmost position of the associated aligned segment set.
- */
-
- /*! \function DbU::Unit TrackSegment::getCanonicalInterval () const;
- * \Return The canonical interval of the associated aligned segment set.
- */
-
- /* \function DbU::Unit TrackSegment::getOverlapCost ( Interval interval, Net* net ) const;
- * \param interval the overlaping interval.
- * \param net the \Net owning the overlaping interval.
- * \return The cost of overlaping the TrackSegment with \e interval from \Net \e net.
- */
-
- // \}
-
-
- /*! \name Modifiers
- */
- // \{
-
- /*! \function void TrackSegment::setLock ( bool state );
- * \param state set the Track locking state.
- */
-
- /*! \function void TrackSegment::setTrack ( Track* track );
- * \param track The Track the TrackSegment is assigned to.
- */
-
- /*! \function void TrackSegment::setIndex ( size_t index );
- * \param index The index of TrackSegment in the Track's vector.
- */
-
- /*! \function void TrackSegment::setArea ();
- * compute the the sorting criterion used as priority, for
- * now it's simply the AutoSegment's slack.
- */
-
- /*! \function void TrackSegment::detach ();
- * remove the TrackSegment from the Track.
+ * The associated DataNegociate and RoutingEvent are \b not updated.
+ * - The RoutingEvent will be updated when it's key is updated,
+ * typically during a requeueing operation \b and in the
+ * SegmentFsm constructor. This should be optimzed in the future.
+ * - The DataNegociate is updated \e only in the SegmentFsm
+ * constructor. This is the most costly of the two updates as
+ * it perform a perpandicular & parallel connexity exploration.
*
- * \important This function do not update the Track itself. The
- * program must take care of it under penalty of introducing
- * incoherencies.
*
- * \see Track::detach().
+ * \section secDogleg Dogleg Management
+ *
+ * The basic AutoSegment::canDogleg() method is declined in three more
+ * dedicated methods in this class:
+ * - TrackSegment::canDogleg(), for locals only, check if a break
+ * is possible, never break a segment more than once (to avoid
+ * fragmentation).
+ * - TrackSegment::canDogleg(Katabatic::GCell*,unsigned int flags)
+ * for globals, check that the segment is breakable in the desired
+ * GCell. Never break twice in the first/last GCell (fragmentation
+ * limitation), but may \e reuse an already existing dogleg.
+ * - TrackSegment::canDogleg(Interval), for locals only, direct proxy
+ * for the AutoSegment method. Never allow more than one break.
+ *
+ * Relationship between AutoSegment and TrackSegment
+ *
+ * Figure 2 below, shows an example of dogleg creation:
+ * - At the Katabatic level, AutoSegment \c id:12 is broken. Thus
+ * the creation of AutoSegments \c id:20 and \c id:21. As per
+ * specification, the orignal segment \c id:10 remains on the
+ * left side (source) of the break.
+ * - But, because the canonical of the former aligned AutoSegment
+ * set \c (10,11,12,13,14) was on the \e right side of the break,
+ * the new parallel TrackSegment will be created on the \c left
+ * side, associated to the newly promoted canonical AutoSegment
+ * \c id:12.
+ *
+ * \image html _makeDogleg-10.png "Fig 2: Dogleg Management"
+ *
+ * The TrackSegment::_postDoglegs() method called by all flavors of
+ * TrackSegment::makeDogleg() methods is responsible for creating new
+ * TrackSegments for the new doglegs (there may be more than one), it
+ * also update the dogleg level and source/target dogleg flags.
+ *
+ * \redB{This section is not finished.} I need to review the parent and
+ * doglevel numbering management. There seems to be a risk of infinite
+ * fragmentation as the numbering of the original segment is not
+ * increased, we should create a \e break counter separate from
+ * deepness.
+ *
+ *
+ * \section secWeakGlobal Global, Weak Global and Local Segments
+ *
+ * There's a slight semantic change between Katabatic and Kite about
+ * what is local and what is local. This is due to how we consider the
+ * intermediate status of \e WeakGlobal.
+ *
+ * A \c WeakGlobal segment is a local segment which is aligned with a
+ * global (though a VTee or an HTee contact).
+ *
+ * In Katabatic a local segment is one that is not \c Global, a local segment
+ * can be both \c Local and \c WeakGlobal.
+ *
+ * In Kite a local segment is one that is neither \c Global or \c WeakGlobal.
+ * The \c WeakGlobal sides with \c Global unlike in Katabatic.
+ *
*/
- /* \function void TrackSegment::autoInvalidate ();
- * add \e this TrackSegment to the Kite level update Session.
- * Something maybe buggy here, or at least not very clean.
- */
+ //! \function static TrackSegment* TrackSegment::create ( AutoSegment* segment, Track* track, bool& created );
+ //! \param segment The Katabatic AutoSegment to decorate.
+ //! \param track A Track into which insert the TrackSegment (may be \NULL).
+ //! \param created This flag is sets is a new TrackSegment has be created.
+ //! \return A TrackSegment wrapped around an AutoSegment.
+ //!
+ //! Constructor mainly used at loading time to decorate the Katabatic
+ //! data-base with the router attributes.
- /* \function void TrackSegment::refreshCanonical ();
- * Recompute the letfmost & rightmost position of the collapsed set.
- * Must be done after each modification of the TrackSegment.
- * Dealt by the TrackSession mechanism.
- *
- */
+ //! \function unsigned long TrackElement::getFreedomDegree() const;
+ //! \sreturn The degree of freedom of the element. It is used as a priority value
+ //! when sorting TrackElement (in RoutingEvent).
+ //!
+ //! Currently, it is the \e slack of the Katabatic::AutoSegment.
- // \}
+ //! \function void TrackSegment::revalidate ();
+ //! Actualize the TrackSegment characteristics from the supporting
+ //! elements (set of AutoSegment).
+ //!
+ //! This method do not update the DataNegociate or the RoutingEvent.
+ //! This is a lazy update delayed until the constructor of SegmentFsm is called.
+ //! (see \ref secTSLazyRevalidate "Lazy Revalidate").
+
+ //! \function TrackSegment* TrackSegment::_postDoglegs ( TrackElement*& perpandicular, TrackElement*& parallel );
+ //! Post-process to be called inside the various dogleg creation or slacken
+ //! methods. Iterate through the newly created AutoSegments to create, for
+ //! the perpandicular and the new parallel associateds
+ //! TrackSegments. Also sets the dogleg levels and flags of the newly
+ //! created elements.
+ //!
+ //! The session dogleg reset is called at the end of this method. The \c perpandicular
+ //! and \c parallel references to pointers contains the newly created segments
+ //! for the \b last dogleg. If more than one was created, you cannot access them
+ //! (the need has not arised yet).
}
diff --git a/kite/doc/asimbook.cls b/kite/doc/asimbook.cls
deleted file mode 100644
index 54270780..00000000
--- a/kite/doc/asimbook.cls
+++ /dev/null
@@ -1,798 +0,0 @@
-%%
-%% This is file `book.cls',
-%% generated with the docstrip utility.
-%%
-%% The original source files were:
-%%
-%% classes.dtx (with options: `book')
-%%
-%% This is a generated file.
-%%
-%% Copyright 1993 1994 1995 1996 1997 1998 1999 2000 2001
-%% The LaTeX3 Project and any individual authors listed elsewhere
-%% in this file.
-%%
-%% This file was generated from file(s) of the LaTeX base system.
-%% --------------------------------------------------------------
-%%
-%% It may be distributed and/or modified under the
-%% conditions of the LaTeX Project Public License, either version 1.2
-%% of this license or (at your option) any later version.
-%% The latest version of this license is in
-%% http://www.latex-project.org/lppl.txt
-%% and version 1.2 or later is part of all distributions of LaTeX
-%% version 1999/12/01 or later.
-%%
-%% This file may only be distributed together with a copy of the LaTeX
-%% base system. You may however distribute the LaTeX base system without
-%% such generated files.
-%%
-%% The list of all files belonging to the LaTeX base distribution is
-%% given in the file `manifest.txt'. See also `legal.txt' for additional
-%% information.
-%%
-%% \CharacterTable
-%% {Upper-case \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z
-%% Lower-case \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z
-%% Digits \0\1\2\3\4\5\6\7\8\9
-%% Exclamation \! Double quote \" Hash (number) \#
-%% Dollar \$ Percent \% Ampersand \&
-%% Acute accent \' Left paren \( Right paren \)
-%% Asterisk \* Plus \+ Comma \,
-%% Minus \- Point \. Solidus \/
-%% Colon \: Semicolon \; Less than \<
-%% Equals \= Greater than \> Question mark \?
-%% Commercial at \@ Left bracket \[ Backslash \\
-%% Right bracket \] Circumflex \^ Underscore \_
-%% Grave accent \` Left brace \{ Vertical bar \|
-%% Right brace \} Tilde \~}
-\NeedsTeXFormat{LaTeX2e}[1995/12/01]
-\ProvidesClass{asimbook}
- [2005/11/21 v1.0
- ASIM LaTeX document class]
-\newcommand\@ptsize{}
-\newif\if@restonecol
-\newif\if@titlepage
-\@titlepagetrue
-\newif\if@openright
-\newif\if@mainmatter \@mainmattertrue
-\if@compatibility\else
-\DeclareOption{a4paper}
- {\setlength\paperheight {297mm}%
- \setlength\paperwidth {210mm}}
-\DeclareOption{a5paper}
- {\setlength\paperheight {210mm}%
- \setlength\paperwidth {148mm}}
-\DeclareOption{b5paper}
- {\setlength\paperheight {250mm}%
- \setlength\paperwidth {176mm}}
-\DeclareOption{letterpaper}
- {\setlength\paperheight {11in}%
- \setlength\paperwidth {8.5in}}
-\DeclareOption{legalpaper}
- {\setlength\paperheight {14in}%
- \setlength\paperwidth {8.5in}}
-\DeclareOption{executivepaper}
- {\setlength\paperheight {10.5in}%
- \setlength\paperwidth {7.25in}}
-\DeclareOption{landscape}
- {\setlength\@tempdima {\paperheight}%
- \setlength\paperheight {\paperwidth}%
- \setlength\paperwidth {\@tempdima}}
-\fi
-\if@compatibility
- \renewcommand\@ptsize{0}
-\else
-\DeclareOption{10pt}{\renewcommand\@ptsize{0}}
-\fi
-\DeclareOption{11pt}{\renewcommand\@ptsize{1}}
-\DeclareOption{12pt}{\renewcommand\@ptsize{2}}
-\if@compatibility\else
-\DeclareOption{oneside}{\@twosidefalse \@mparswitchfalse}
-\fi
-\DeclareOption{twoside}{\@twosidetrue \@mparswitchtrue}
-\DeclareOption{draft}{\setlength\overfullrule{5pt}}
-\if@compatibility\else
-\DeclareOption{final}{\setlength\overfullrule{0pt}}
-\fi
-\DeclareOption{titlepage}{\@titlepagetrue}
-\if@compatibility\else
-\DeclareOption{notitlepage}{\@titlepagefalse}
-\fi
-\if@compatibility
-\@openrighttrue
-\else
-\DeclareOption{openright}{\@openrighttrue}
-\DeclareOption{openany}{\@openrightfalse}
-\fi
-\if@compatibility\else
-\DeclareOption{onecolumn}{\@twocolumnfalse}
-\fi
-\DeclareOption{twocolumn}{\@twocolumntrue}
-\DeclareOption{leqno}{\input{leqno.clo}}
-\DeclareOption{fleqn}{\input{fleqn.clo}}
-\DeclareOption{openbib}{%
- \AtEndOfPackage{%
- \renewcommand\@openbib@code{%
- \advance\leftmargin\bibindent
- \itemindent -\bibindent
- \listparindent \itemindent
- \parsep \z@
- }%
- \renewcommand\newblock{\par}}%
-}
-\ExecuteOptions{letterpaper,10pt,twoside,onecolumn,final,openright}
-\ProcessOptions
-\input{bk1\@ptsize.clo}
-\setlength\lineskip{1\p@}
-\setlength\normallineskip{1\p@}
-\renewcommand\baselinestretch{}
-\setlength\parskip{0\p@ \@plus \p@}
-\@lowpenalty 51
-\@medpenalty 151
-\@highpenalty 301
-\setcounter{topnumber}{2}
-\renewcommand\topfraction{.7}
-\setcounter{bottomnumber}{1}
-\renewcommand\bottomfraction{.3}
-\setcounter{totalnumber}{3}
-\renewcommand\textfraction{.2}
-\renewcommand\floatpagefraction{.5}
-\setcounter{dbltopnumber}{2}
-\renewcommand\dbltopfraction{.7}
-\renewcommand\dblfloatpagefraction{.5}
-%%%% Select Chapter font.
-\newcommand \textchapter [1] {\textsf{\textbf{#1}}}
-\newcommand \fontchapter {\sffamily \bfseries}
-\if@twoside
- \def\ps@headings{%
- \let\@oddfoot\@empty\let\@evenfoot\@empty
- \def\@evenhead{\thepage\hfil\slshape\leftmark}%
- \def\@oddhead{{\slshape\rightmark}\hfil\thepage}%
- \let\@mkboth\markboth
- \def\chaptermark##1{%
- \markboth {\MakeUppercase{%
- \ifnum \c@secnumdepth >\m@ne
- \if@mainmatter
- \@chapapp\ \thechapter. \ %
- \fi
- \fi
- ##1}}{}}%
- \def\sectionmark##1{%
- \markright {\MakeUppercase{%
- \ifnum \c@secnumdepth >\z@
- \thesection. \ %
- \fi
- ##1}}}}
-\else
- \def\ps@headings{%
- \let\@oddfoot\@empty
- \def\@oddhead{{\slshape\rightmark}\hfil\thepage}%
- \let\@mkboth\markboth
- \def\chaptermark##1{%
- \markright {\MakeUppercase{%
- \ifnum \c@secnumdepth >\m@ne
- \if@mainmatter
- \@chapapp\ \thechapter. \ %
- \fi
- \fi
- ##1}}}}
-\fi
-\def\ps@myheadings{%
- \let\@oddfoot\@empty\let\@evenfoot\@empty
- \def\@evenhead{\thepage\hfil\slshape\leftmark}%
- \def\@oddhead{{\slshape\rightmark}\hfil\thepage}%
- \let\@mkboth\@gobbletwo
- \let\chaptermark\@gobble
- \let\sectionmark\@gobble
- }
- \if@titlepage
- \newcommand\maketitle{\begin{titlepage}%
- \let\footnotesize\small
- \let\footnoterule\relax
- \let \footnote \thanks
- \null\vfil
- \vskip 60\p@
- \begin{center}%
- {\LARGE \@title \par}%
- \vskip 3em%
- {\large
- \lineskip .75em%
- \begin{tabular}[t]{c}%
- \@author
- \end{tabular}\par}%
- \vskip 1.5em%
- {\large \@date \par}% % Set date in \large size.
- \end{center}\par
- \@thanks
- \vfil\null
- \end{titlepage}%
- \setcounter{footnote}{0}%
- \global\let\thanks\relax
- \global\let\maketitle\relax
- \global\let\@thanks\@empty
- \global\let\@author\@empty
- \global\let\@date\@empty
- \global\let\@title\@empty
- \global\let\title\relax
- \global\let\author\relax
- \global\let\date\relax
- \global\let\and\relax
-}
-\else
-\newcommand\maketitle{\par
- \begingroup
- \renewcommand\thefootnote{\@fnsymbol\c@footnote}%
- \def\@makefnmark{\rlap{\@textsuperscript{\normalfont\@thefnmark}}}%
- \long\def\@makefntext##1{\parindent 1em\noindent
- \hb@xt@1.8em{%
- \hss\@textsuperscript{\normalfont\@thefnmark}}##1}%
- \if@twocolumn
- \ifnum \col@number=\@ne
- \@maketitle
- \else
- \twocolumn[\@maketitle]%
- \fi
- \else
- \newpage
- \global\@topnum\z@ % Prevents figures from going at top of page.
- \@maketitle
- \fi
- \thispagestyle{plain}\@thanks
- \endgroup
- \setcounter{footnote}{0}%
- \global\let\thanks\relax
- \global\let\maketitle\relax
- \global\let\@maketitle\relax
- \global\let\@thanks\@empty
- \global\let\@author\@empty
- \global\let\@date\@empty
- \global\let\@title\@empty
- \global\let\title\relax
- \global\let\author\relax
- \global\let\date\relax
- \global\let\and\relax
-}
-\def\@maketitle{%
- \newpage
- \null
- \vskip 2em%
- \begin{center}%
- \let \footnote \thanks
- {\LARGE \@title \par}%
- \vskip 1.5em%
- {\large
- \lineskip .5em%
- \begin{tabular}[t]{c}%
- \@author
- \end{tabular}\par}%
- \vskip 1em%
- {\large \@date}%
- \end{center}%
- \par
- \vskip 1.5em}
-\fi
-\newcommand*\chaptermark[1]{}
-\setcounter{secnumdepth}{2}
-\newcounter {part}
-\newcounter {chapter}
-\newcounter {section}[chapter]
-\newcounter {subsection}[section]
-\newcounter {subsubsection}[subsection]
-\newcounter {paragraph}[subsubsection]
-\newcounter {subparagraph}[paragraph]
-\renewcommand \thepart {\@Roman\c@part}
-\renewcommand \thechapter {\@arabic\c@chapter}
-\renewcommand \thesection {\thechapter.\@arabic\c@section}
-\renewcommand\thesubsection {\thesection.\@arabic\c@subsection}
-\renewcommand\thesubsubsection{\thesubsection .\@arabic\c@subsubsection}
-\renewcommand\theparagraph {\thesubsubsection.\@arabic\c@paragraph}
-\renewcommand\thesubparagraph {\theparagraph.\@arabic\c@subparagraph}
-\newcommand\@chapapp{\chaptername}
-\newcommand\frontmatter{%
- \cleardoublepage
- \@mainmatterfalse
- \pagenumbering{roman}}
-\newcommand\mainmatter{%
- \cleardoublepage
- \@mainmattertrue
- \pagenumbering{arabic}}
-\newcommand\backmatter{%
- \if@openright
- \cleardoublepage
- \else
- \clearpage
- \fi
- \@mainmatterfalse}
-\newcommand\part{%
- \if@openright
- \cleardoublepage
- \else
- \clearpage
- \fi
- \thispagestyle{plain}%
- \if@twocolumn
- \onecolumn
- \@tempswatrue
- \else
- \@tempswafalse
- \fi
- \null\vfil
- \secdef\@part\@spart}
-
-\def\@part[#1]#2{%
- \ifnum \c@secnumdepth >-2\relax
- \refstepcounter{part}%
- \addcontentsline{toc}{part}{\thepart\hspace{1em}#1}%
- \else
- \addcontentsline{toc}{part}{#1}%
- \fi
- \markboth{}{}%
- {\centering
- \interlinepenalty \@M
- \normalfont
- \ifnum \c@secnumdepth >-2\relax
- \huge\bfseries \partname\nobreakspace\thepart
- \par
- \vskip 20\p@
- \fi
- \Huge \bfseries #2\par}%
- \@endpart}
-\def\@spart#1{%
- {\centering
- \interlinepenalty \@M
- \normalfont
- \Huge \bfseries #1\par}%
- \@endpart}
-\def\@endpart{\vfil\newpage
- \if@twoside
- \if@openright
- \null
- \thispagestyle{empty}%
- \newpage
- \fi
- \fi
- \if@tempswa
- \twocolumn
- \fi}
-\newcommand\chapter{\if@openright\cleardoublepage\else\clearpage\fi
- \thispagestyle{plain}%
- \global\@topnum\z@
- \@afterindentfalse
- \secdef\@chapter\@schapter}
-\def\@chapter[#1]#2{\ifnum \c@secnumdepth >\m@ne
- \if@mainmatter
- \refstepcounter{chapter}%
- \typeout{\@chapapp\space\thechapter.}%
- \addcontentsline{toc}{chapter}%
- {\protect\numberline{\thechapter}#1}%
- \else
- \addcontentsline{toc}{chapter}{#1}%
- \fi
- \else
- \addcontentsline{toc}{chapter}{#1}%
- \fi
- \chaptermark{#1}%
- \addtocontents{lof}{\protect\addvspace{10\p@}}%
- \addtocontents{lot}{\protect\addvspace{10\p@}}%
- \if@twocolumn
- \@topnewpage[\@makechapterhead{#2}]%
- \else
- \@makechapterhead{#2}%
- \@afterheading
- \fi}
-%%%%\def\@makechapterhead#1{%
-%%%% \vspace*{50\p@}%
-%%%% {\parindent \z@ \raggedright \normalfont
-%%%% \ifnum \c@secnumdepth >\m@ne
-%%%% \if@mainmatter
-%%%% \huge\bfseries \@chapapp\space \thechapter
-%%%% \par\nobreak
-%%%% \vskip 20\p@
-%%%% \fi
-%%%% \fi
-%%%% \interlinepenalty\@M
-%%%% \Huge \bfseries #1\par\nobreak
-%%%% \vskip 40\p@
-%%%% }}
- \newlength \titlewidth
- \setlength \titlewidth {\textwidth}
- \addtolength \titlewidth {\marginparwidth}
- \addtolength \titlewidth {\marginparsep}
- \def\@makechapterhead#1{%
- \vspace*{50\p@}%
- {\parindent \z@ \raggedleft \fontchapter
- \ifnum \c@secnumdepth >\m@ne
- \if@mainmatter
- \huge \@chapapp\space \thechapter
- \par\nobreak
- \vskip 20\p@
- \fi
- \fi
- \interlinepenalty\@M
- \hsize=\titlewidth
- \Huge #1 \par\nobreak
- \hsize=\textwidth
- \vskip 40\p@
- }}
-\def\@schapter#1{\if@twocolumn
- \@topnewpage[\@makeschapterhead{#1}]%
- \else
- \@makeschapterhead{#1}%
- \@afterheading
- \fi}
-%%%%\def\@makeschapterhead#1{%
-%%%% \vspace*{50\p@}%
-%%%% {\parindent \z@ \raggedright
-%%%% \normalfont
-%%%% \interlinepenalty\@M
-%%%% \Huge \bfseries #1\par\nobreak
-%%%% \vskip 40\p@
-%%%% }}
- \def\@makeschapterhead#1{%
- \vspace*{50\p@}%
- {\parindent \z@ \raggedright
- \normalfont
- \interlinepenalty\@M
- \hsize=\titlewidth
- \flushright
- \Huge \bfseries #1\par\nobreak
- \hsize=\textwidth
- \vskip 40\p@
- }}
-\newcommand\section{\@startsection {section}{1}{\z@}%
- {-3.5ex \@plus -1ex \@minus -.2ex}%
- {2.3ex \@plus.2ex}%
- {\normalfont\Large\bfseries}}
-\newcommand\subsection{\@startsection{subsection}{2}{\z@}%
- {-3.25ex\@plus -1ex \@minus -.2ex}%
- {1.5ex \@plus .2ex}%
- {\normalfont\large\bfseries}}
-\newcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}%
- {-3.25ex\@plus -1ex \@minus -.2ex}%
- {1.5ex \@plus .2ex}%
- {\normalfont\normalsize\bfseries}}
-\newcommand\paragraph{\@startsection{paragraph}{4}{\z@}%
- {3.25ex \@plus1ex \@minus.2ex}%
- {-1em}%
- {\normalfont\normalsize\bfseries}}
-\newcommand\subparagraph{\@startsection{subparagraph}{5}{\parindent}%
- {3.25ex \@plus1ex \@minus .2ex}%
- {-1em}%
- {\normalfont\normalsize\bfseries}}
-\if@twocolumn
- \setlength\leftmargini {2em}
-\else
- \setlength\leftmargini {2.5em}
-\fi
-\leftmargin \leftmargini
-\setlength\leftmarginii {2.2em}
-\setlength\leftmarginiii {1.87em}
-\setlength\leftmarginiv {1.7em}
-\if@twocolumn
- \setlength\leftmarginv {.5em}
- \setlength\leftmarginvi {.5em}
-\else
- \setlength\leftmarginv {1em}
- \setlength\leftmarginvi {1em}
-\fi
-\setlength \labelsep {.5em}
-\setlength \labelwidth{\leftmargini}
-\addtolength\labelwidth{-\labelsep}
-\@beginparpenalty -\@lowpenalty
-\@endparpenalty -\@lowpenalty
-\@itempenalty -\@lowpenalty
-\renewcommand\theenumi{\@arabic\c@enumi}
-\renewcommand\theenumii{\@alph\c@enumii}
-\renewcommand\theenumiii{\@roman\c@enumiii}
-\renewcommand\theenumiv{\@Alph\c@enumiv}
-\newcommand\labelenumi{\theenumi.}
-\newcommand\labelenumii{(\theenumii)}
-\newcommand\labelenumiii{\theenumiii.}
-\newcommand\labelenumiv{\theenumiv.}
-\renewcommand\p@enumii{\theenumi}
-\renewcommand\p@enumiii{\theenumi(\theenumii)}
-\renewcommand\p@enumiv{\p@enumiii\theenumiii}
-\newcommand\labelitemi{\textbullet}
-\newcommand\labelitemii{\normalfont\bfseries \textendash}
-\newcommand\labelitemiii{\textasteriskcentered}
-\newcommand\labelitemiv{\textperiodcentered}
-\newenvironment{description}
- {\list{}{\labelwidth\z@ \itemindent-\leftmargin
- \let\makelabel\descriptionlabel}}
- {\endlist}
-\newcommand*\descriptionlabel[1]{\hspace\labelsep
- \normalfont\bfseries #1}
-\newenvironment{verse}
- {\let\\\@centercr
- \list{}{\itemsep \z@
- \itemindent -1.5em%
- \listparindent\itemindent
- \rightmargin \leftmargin
- \advance\leftmargin 1.5em}%
- \item\relax}
- {\endlist}
-\newenvironment{quotation}
- {\list{}{\listparindent 1.5em%
- \itemindent \listparindent
- \rightmargin \leftmargin
- \parsep \z@ \@plus\p@}%
- \item\relax}
- {\endlist}
-\newenvironment{quote}
- {\list{}{\rightmargin\leftmargin}%
- \item\relax}
- {\endlist}
-\if@compatibility
-\newenvironment{titlepage}
- {%
- \cleardoublepage
- \if@twocolumn
- \@restonecoltrue\onecolumn
- \else
- \@restonecolfalse\newpage
- \fi
- \thispagestyle{empty}%
- \setcounter{page}\z@
- }%
- {\if@restonecol\twocolumn \else \newpage \fi
- }
-\else
-\newenvironment{titlepage}
- {%
- \cleardoublepage
- \if@twocolumn
- \@restonecoltrue\onecolumn
- \else
- \@restonecolfalse\newpage
- \fi
- \thispagestyle{empty}%
- \setcounter{page}\@ne
- }%
- {\if@restonecol\twocolumn \else \newpage \fi
- \if@twoside\else
- \setcounter{page}\@ne
- \fi
- }
-\fi
-\newcommand\appendix{\par
- \setcounter{chapter}{0}%
- \setcounter{section}{0}%
- \gdef\@chapapp{\appendixname}%
- \gdef\thechapter{\@Alph\c@chapter}}
-\setlength\arraycolsep{5\p@}
-\setlength\tabcolsep{6\p@}
-\setlength\arrayrulewidth{.4\p@}
-\setlength\doublerulesep{2\p@}
-\setlength\tabbingsep{\labelsep}
-\skip\@mpfootins = \skip\footins
-\setlength\fboxsep{3\p@}
-\setlength\fboxrule{.4\p@}
-\@addtoreset {equation}{chapter}
-\renewcommand\theequation
- {\ifnum \c@chapter>\z@ \thechapter.\fi \@arabic\c@equation}
-\newcounter{figure}[chapter]
-\renewcommand \thefigure
- {\ifnum \c@chapter>\z@ \thechapter.\fi \@arabic\c@figure}
-\def\fps@figure{tbp}
-\def\ftype@figure{1}
-\def\ext@figure{lof}
-\def\fnum@figure{\figurename\nobreakspace\thefigure}
-\newenvironment{figure}
- {\@float{figure}}
- {\end@float}
-\newenvironment{figure*}
- {\@dblfloat{figure}}
- {\end@dblfloat}
-\newcounter{table}[chapter]
-\renewcommand \thetable
- {\ifnum \c@chapter>\z@ \thechapter.\fi \@arabic\c@table}
-\def\fps@table{tbp}
-\def\ftype@table{2}
-\def\ext@table{lot}
-\def\fnum@table{\tablename\nobreakspace\thetable}
-\newenvironment{table}
- {\@float{table}}
- {\end@float}
-\newenvironment{table*}
- {\@dblfloat{table}}
- {\end@dblfloat}
-\newlength\abovecaptionskip
-\newlength\belowcaptionskip
-\setlength\abovecaptionskip{10\p@}
-\setlength\belowcaptionskip{0\p@}
-\long\def\@makecaption#1#2{%
- \vskip\abovecaptionskip
- \sbox\@tempboxa{#1: #2}%
- \ifdim \wd\@tempboxa >\hsize
- #1: #2\par
- \else
- \global \@minipagefalse
- \hb@xt@\hsize{\hfil\box\@tempboxa\hfil}%
- \fi
- \vskip\belowcaptionskip}
-\DeclareOldFontCommand{\rm}{\normalfont\rmfamily}{\mathrm}
-\DeclareOldFontCommand{\sf}{\normalfont\sffamily}{\mathsf}
-\DeclareOldFontCommand{\tt}{\normalfont\ttfamily}{\mathtt}
-\DeclareOldFontCommand{\bf}{\normalfont\bfseries}{\mathbf}
-\DeclareOldFontCommand{\it}{\normalfont\itshape}{\mathit}
-\DeclareOldFontCommand{\sl}{\normalfont\slshape}{\@nomath\sl}
-\DeclareOldFontCommand{\sc}{\normalfont\scshape}{\@nomath\sc}
-\DeclareRobustCommand*\cal{\@fontswitch\relax\mathcal}
-\DeclareRobustCommand*\mit{\@fontswitch\relax\mathnormal}
-\newcommand\@pnumwidth{1.55em}
-\newcommand\@tocrmarg{2.55em}
-\newcommand\@dotsep{4.5}
-\setcounter{tocdepth}{2}
-\newcommand\tableofcontents{%
- \if@twocolumn
- \@restonecoltrue\onecolumn
- \else
- \@restonecolfalse
- \fi
- \chapter*{\contentsname
- \@mkboth{%
- \MakeUppercase\contentsname}{\MakeUppercase\contentsname}}%
- \@starttoc{toc}%
- \if@restonecol\twocolumn\fi
- }
-\newcommand*\l@part[2]{%
- \ifnum \c@tocdepth >-2\relax
- \addpenalty{-\@highpenalty}%
- \addvspace{2.25em \@plus\p@}%
- \setlength\@tempdima{3em}%
- \begingroup
- \parindent \z@ \rightskip \@pnumwidth
- \parfillskip -\@pnumwidth
- {\leavevmode
- \large \bfseries #1\hfil \hb@xt@\@pnumwidth{\hss #2}}\par
- \nobreak
- \global\@nobreaktrue
- \everypar{\global\@nobreakfalse\everypar{}}%
- \endgroup
- \fi}
-%%%%\newcommand*\l@chapter[2]{%
-%%%% \ifnum \c@tocdepth >\m@ne
-%%%% \addpenalty{-\@highpenalty}%
-%%%% \vskip 1.0em \@plus\p@
-%%%% \setlength\@tempdima{1.5em}%
-%%%% \begingroup
-%%%% \parindent \z@ \rightskip \@pnumwidth
-%%%% \parfillskip -\@pnumwidth
-%%%% \leavevmode \bfseries
-%%%% \advance\leftskip\@tempdima
-%%%% \hskip -\leftskip
-%%%% #1\nobreak\hfil \nobreak\hb@xt@\@pnumwidth{\hss #2}\par
-%%%% \penalty\@highpenalty
-%%%% \endgroup
-%%%% \fi}
-\newcommand\l@chapter[2]{%
- \ifnum \c@tocdepth >\m@ne
- \addpenalty{-\@highpenalty}%
- \vskip 1.0em \@plus\p@
- \setlength\@tempdima{1.5em}%
- \begingroup
- \parindent \z@ \rightskip \@pnumwidth
- \parfillskip -\@pnumwidth
- \leavevmode \fontchapter
- \advance\leftskip\@tempdima
- \hskip -\leftskip
- #1\nobreak\hfil \nobreak\hb@xt@\@pnumwidth{\hss #2}\par
- \penalty\@highpenalty
- \endgroup
- \fi}
-\newcommand*\l@section{\@dottedtocline{1}{1.5em}{2.3em}}
-\newcommand*\l@subsection{\@dottedtocline{2}{3.8em}{3.2em}}
-\newcommand*\l@subsubsection{\@dottedtocline{3}{7.0em}{4.1em}}
-\newcommand*\l@paragraph{\@dottedtocline{4}{10em}{5em}}
-\newcommand*\l@subparagraph{\@dottedtocline{5}{12em}{6em}}
-\newcommand\listoffigures{%
- \if@twocolumn
- \@restonecoltrue\onecolumn
- \else
- \@restonecolfalse
- \fi
- \chapter*{\listfigurename}%
- \@mkboth{\MakeUppercase\listfigurename}%
- {\MakeUppercase\listfigurename}%
- \@starttoc{lof}%
- \if@restonecol\twocolumn\fi
- }
-\newcommand*\l@figure{\@dottedtocline{1}{1.5em}{2.3em}}
-\newcommand\listoftables{%
- \if@twocolumn
- \@restonecoltrue\onecolumn
- \else
- \@restonecolfalse
- \fi
- \chapter*{\listtablename}%
- \@mkboth{%
- \MakeUppercase\listtablename}%
- {\MakeUppercase\listtablename}%
- \@starttoc{lot}%
- \if@restonecol\twocolumn\fi
- }
-\let\l@table\l@figure
-\newdimen\bibindent
-\setlength\bibindent{1.5em}
-\newenvironment{thebibliography}[1]
- {\chapter*{\bibname}%
- \@mkboth{\MakeUppercase\bibname}{\MakeUppercase\bibname}%
- \list{\@biblabel{\@arabic\c@enumiv}}%
- {\settowidth\labelwidth{\@biblabel{#1}}%
- \leftmargin\labelwidth
- \advance\leftmargin\labelsep
- \@openbib@code
- \usecounter{enumiv}%
- \let\p@enumiv\@empty
- \renewcommand\theenumiv{\@arabic\c@enumiv}}%
- \sloppy
- \clubpenalty4000
- \@clubpenalty \clubpenalty
- \widowpenalty4000%
- \sfcode`\.\@m}
- {\def\@noitemerr
- {\@latex@warning{Empty `thebibliography' environment}}%
- \endlist}
-\newcommand\newblock{\hskip .11em\@plus.33em\@minus.07em}
-\let\@openbib@code\@empty
-\newenvironment{theindex}
- {\if@twocolumn
- \@restonecolfalse
- \else
- \@restonecoltrue
- \fi
- \columnseprule \z@
- \columnsep 35\p@
- \twocolumn[\@makeschapterhead{\indexname}]%
- \@mkboth{\MakeUppercase\indexname}%
- {\MakeUppercase\indexname}%
- \thispagestyle{plain}\parindent\z@
- \parskip\z@ \@plus .3\p@\relax
- \let\item\@idxitem}
- {\if@restonecol\onecolumn\else\clearpage\fi}
-\newcommand\@idxitem{\par\hangindent 40\p@}
-\newcommand\subitem{\@idxitem \hspace*{20\p@}}
-\newcommand\subsubitem{\@idxitem \hspace*{30\p@}}
-\newcommand\indexspace{\par \vskip 10\p@ \@plus5\p@ \@minus3\p@\relax}
-\renewcommand\footnoterule{%
- \kern-3\p@
- \hrule\@width.4\columnwidth
- \kern2.6\p@}
-\@addtoreset{footnote}{chapter}
-\newcommand\@makefntext[1]{%
- \parindent 1em%
- \noindent
- \hb@xt@1.8em{\hss\@makefnmark}#1}
-\newcommand\contentsname{Contents}
-\newcommand\listfigurename{List of Figures}
-\newcommand\listtablename{List of Tables}
-\newcommand\bibname{Bibliography}
-\newcommand\indexname{Index}
-\newcommand\figurename{Figure}
-\newcommand\tablename{Table}
-\newcommand\partname{Part}
-\newcommand\chaptername{Chapter}
-\newcommand\appendixname{Appendix}
-\def\today{\ifcase\month\or
- January\or February\or March\or April\or May\or June\or
- July\or August\or September\or October\or November\or December\fi
- \space\number\day, \number\year}
-\setlength\columnsep{10\p@}
-\setlength\columnseprule{0\p@}
-\pagestyle{headings}
-\pagenumbering{arabic}
-\if@twoside
-\else
- \raggedbottom
-\fi
-\if@twocolumn
- \twocolumn
- \sloppy
- \flushbottom
-\else
- \onecolumn
-\fi
-\endinput
-%%
-%% End of file `book.cls'.
diff --git a/kite/doc/doxyfile b/kite/doc/doxyfile
index a51583ff..9824b7d8 100644
--- a/kite/doc/doxyfile
+++ b/kite/doc/doxyfile
@@ -1,3 +1,5 @@
+# -*- explicit-buffer-name: "doxyfile
Kite - Detailed Router
- Copyright © 2008-2009 LIP6. All rights reserved
+ Copyright © 2008-2013 UPMC. All rights reserved
diff --git a/kite/doc/header.html b/kite/doc/header.html index bf039968..0806b4a4 100644 --- a/kite/doc/header.html +++ b/kite/doc/header.html @@ -1,17 +1,16 @@
-
- +
+