ns-3.24: comparison src/core/model/synchronizer.h

equal deleted inserted replaced

-:65ddfcaae79a
+:5d6b3f94ebf3
 #include <stdint.h>
 #include "nstime.h"
 #include "object.h"
 /**
-* \file
+* @file
-* \ingroup realtime
+* @ingroup realtime
 * ns3::Synchronizer declaration.
 */
 namespace ns3 {
 class Synchronizer : public Object
 {
 public:
 /**
 * Get the registered TypeId for this class.
-* \returns The TypeId.
+* @returns The TypeId.
 */
 static TypeId GetTypeId (void);
 /** Constructor. */
 Synchronizer ();
 * @brief Return true if this synchronizer is actually synchronizing to a
 * realtime clock.
 *
 * The simulator sometimes needs to know this.
 *
-* @returns \c true if locked with realtime, \c false if not.
+* @returns @c true if locked with realtime, @c false if not.
 */
 bool Realtime (void);
 /**
 * @brief Retrieve the value of the origin of the underlying normalized wall
 /**
 * @brief Wait until the real time is in sync with the specified simulation
 * time or until the synchronizer is Sigalled.
 *
-* This is where the real work of synchronization is done.  The \c tsCurrent
+* This is where the real work of synchronization is done.  The @c tsCurrent
 * argument is the simulation time.  The job of Synchronize is to
 * translate from simulation time to synchronizer time (in a perfect world
 * this is the same time) and then figure out how long in real-time it needs
 * to wait until that synchronizer / simulation time comes around.
 *
 * requested simulation time.
 *
 * @param tsCurrent The current simulation time (in Time resolution units).
 * @param tsDelay The simulation time we need to wait for (in Time
 *     resolution units).
-* @returns \c true if the function ran to completion,
+* @returns @c true if the function ran to completion,
-*          \c false if it was interrupted by a Signal.
+*          @c false if it was interrupted by a Signal.
 * @see DoSynchronize
 * @see Signal
 */
 bool Synchronize (uint64_t tsCurrent, uint64_t tsDelay);
 * @see SetOrigin
 */
 virtual void DoSetOrigin (uint64_t ns) = 0;
 /**
-* @brief Return \c true if this synchronizer is actually synchronizing to a
+* @brief Return @c true if this synchronizer is actually synchronizing to a
 * realtime clock.
 *
 * The simulator sometimes needs to know this.
 *
 * Subclasses are expected to implement this method to tell the outside world
 * whether or not they are synchronizing to a realtime clock.
 *
-* @returns \c true if locked with realtime, \c false if not.
+* @returns @c true if locked with realtime, @c false if not.
 */
 virtual bool DoRealtime (void) = 0;
 /**
 * @brief Retrieve the value of the origin of the underlying normalized wall
 /**
 * @brief Wait until the real time is in sync with the specified simulation
 * time.
 *
 * This is where the real work of synchronization is done.  The
-* \c nsCurrent argument is the simulation time (in ns).  The job of
+* @c nsCurrent argument is the simulation time (in ns).  The job of
 * DoSynchronize is to translate from simulation time to synchronizer time
 * (in a perfect world these are the same time) and then figure out
 * how long in real-time it needs to wait until that
 * synchronizer / simulation time comes around.
 *
 * or some combination) until the requested simulation time.
 *
 * @param nsCurrent The current simulation time (in nanosecond units).
 * @param nsDelay The simulation time we need to wait for (normalized to
 * nanosecond units).
-* @returns \c true if the function ran to completion,
+* @returns @c true if the function ran to completion,
-*          \c false if it was interrupted by a Signal.
+*          @c false if it was interrupted by a Signal.
 * @see Synchronize
 * @see Signal
 */
 virtual bool DoSynchronize (uint64_t nsCurrent, uint64_t nsDelay) = 0;

changeset 11531	5d6b3f94ebf3
parent 11131	6a448ac28669
child 11538	397bd6465dd9