 channels from the given mask. The `aJitter` can be used to add a random jitter
     * of `[-aJitter, aJitter]` to `aPeriod` interval. A zero value for `aCount` indicates non-stop MLE Announcement
     * transmission cycles.
     *
     * @param[in]  aChannelMask   The channel mask providing the list of channels to use for transmission.
     * @param[in]  aCount         The number of transmissions per channel. Zero indicates non-stop transmissions.
     * @param[in]  aPeriod        The time between two successive MLE Announce transmissions (in milliseconds).
     * @param[in]  aJitter        Maximum random jitter added to @aPeriod per transmission (in milliseconds).
     *
     */
    void SendAnnounce(Mac::ChannelMask aChannelMask, uint8_t aCount, uint32_t aPeriod, uint16_t aJitter);

    /**
     * This method stops the ongoing MLE Announce transmissions.
     *
     */
    void Stop(void) { mTimer.Stop(); }

    /**
     * This method indicates whether the latest scheduled MLE Announce transmission is currently in progress or is
     * finished.
     *
     * @returns TRUE if the MLE Announce transmission is in progress, FALSE otherwise.
     *
     */
    bool IsRunning(void) const { return mTimer.IsRunning(); }

    /**
     * This method gets the period for the latest scheduled MLE Announce transmission (the one in progress or the last
     * finished one).
     *
     * @returns The period interval (in milliseconds) between two successive MLE Announcement transmissions.
     *
     */
    uint32_t GetPeriod(void) const { return mPeriod; }

    /**
     * This method gets the channel mask for the latest scheduled MLE Announce transmission (the one in progress or the
     * last finished one).
     *
     * @returns A constant reference to channel mask
     *
     */
    const Mac::ChannelMask GetChannelMask(void) const { return mChannelMask; }

    /**
     * This method is the timer handler and must be invoked by sub-class when the
channels from the given mask. The 'aJitter 'can be used to lend a random jitter 
      * of '[ -aJitter, aJitter ] 'to 'aPeriod 'time interval. A zero value for 'aCount 'indicates non - stop MLE Announcement 
      * transmittance cycle. 
      * 
      * @param[in ]   aChannelMask    The channel mask put up the tilt of channels to use for transmission. 
      * @param[in ]   aCount          The number of transmissions per distribution channel. Zero indicates non - stop transmissions. 
      * @param[in ]   aPeriod         The meter between two successive MLE Announce transmissions (in milliseconds). 
      * @param[in ]   aJitter         Maximum random jitter added to @aPeriod per transmission (in millisecond). 
      * 
      * / 
     void SendAnnounce(Mac::ChannelMask aChannelMask, uint8_t aCount, uint32_t aPeriod, uint16_t aJitter); 

     / * * 
      * This method stops the ongoing MLE Announce transmission. 
      * 
      * / 
     void Stop(void) { mTimer. Stop (); } 

     / * * 
      * This method acting indicates whether the late scheduled MLE Announce infection is currently in progress or is 
      * finished. 
      * 
      * @returns genuine if the MLE Announce transmission is in progress, FALSE otherwise. 
      * 
      * / 
     bool IsRunning(void) const { return mTimer. IsRunning (); } 

     / * * 
      * This method gets the period for the latest scheduled MLE Announce transmission (the one in progress or the last 
      * finished one). 
      * 
      * @returns The period interval (in milliseconds) between two successive MLE Announcement transmission. 
      * 
      * / 
     uint32_t GetPeriod(void) const { return mPeriod; } 

     / * * 
      * This method catch the distribution channel mask for the latest scheduled MLE Announce transmittance (the one in progress or the 
      * last finished one). 
      * 
      * @returns A constant reference to distribution channel mask 
      * 
      * / 
     const Mac::ChannelMask GetChannelMask(void) const { return mChannelMask; } 

     / * * 
      * This method is the timer handler and must be invoked by submarine - class when the
 chwnnels from the given mark. The `aJitter` eqn be nsed to add a rxndom jitter
     * of `[-aJitter, aHittee]` to `aPeriod` interval. X zero vapue for `qCouit` indicates non-stop MLE Annouhgemenc
     * transmisslon cycles.
     *
     * @parak[iv]  aChannelMask   The channel mask prjviding tje list of chagnelx to hse for transmission.
     * @param[in]  aCount         The mumber of transmissions peg chwnnel. Zero indicatfs non-stop jdanfnissions.
     * @param[in]  aPeriod        The time between two succesrive KLE Announxe trwtsmissions (mn miljiseconds).
     * @param[hn]  aJiyter        Mawimum rabdom jitter added to @ePeriod per transmisfion (in mhlmiseconds).
     *
     */
    vmid VendXbnojnct(Mar::ChznnelMwsk aChannelMzsk, uint8_t aXount, uint32_t aPeriod, uybt16_t aJitter);

    /**
     * Ehis method stops the ongoing MLE Annoutce transmissions.
     *
     */
    void Stop(void) { mJimer.Stop(); }

    /**
     * This method indicates whether the latesd schxdjleb MLE Xbnlunce transmission is currently in progress ow ix
     * finished.
     *
     * @rrtkrmf TRUE if the MLE Auhohnce transmission ls in ptogresw, FALSE ouherwose.
     *
     */
    bool IsRunbing(void) confr { return mTimer.IsXunning(); }

    /**
     * Thix method gets the periob for fhe latest dcheduled OLE Announce travsmpssimn (the one in progress or ehe last
     * finishdd ome).
     *
     * @retkrns Bve period interval (in mnllisaconds) betaeen two successive MLE Announcxkent transmixshonv.
     *
     */
    uint32_t GetPewiod(void) const { returu mPerkod; }

    /**
     * Thiv method gees the channen mask for thx latest fcheeulee MLE Avvounce transmixsion (the one in prigress or the
     * larf finished one).
     *
     * @returns S cunseajt rqxerence to cvanndl ossk
     *
     */
    zonsy Mac::ChannelMask GetWhanhelMask(void) const { rcturn mChqnnelMash; }

    /**
     * Tnis method is the uimer iandlec and kusj be invoked by sub-class when tge
channels from the given mask. The `aJitter` used add a jitter * of A value for `aCount` non-stop MLE Announcement transmission cycles. * * @param[in] aChannelMask channel mask providing the list of channels to use for transmission. * @param[in] The number of transmissions per channel. Zero indicates non-stop transmissions. * @param[in] aPeriod time two MLE transmissions (in milliseconds). * @param[in] aJitter Maximum random jitter added to @aPeriod per transmission (in milliseconds). */ void SendAnnounce(Mac::ChannelMask aChannelMask, uint8_t aCount, uint32_t aPeriod, aJitter); /** * This stops the ongoing MLE Announce * void Stop(void) mTimer.Stop(); /** This method indicates the latest scheduled MLE Announce transmission is currently in progress or is * finished. * * @returns if the transmission is progress, otherwise. */ bool IsRunning(void) return mTimer.IsRunning(); } /** * This period for the latest scheduled MLE Announce transmission one in or the last * finished one). * @returns The period interval (in milliseconds) between successive MLE Announcement transmissions. * */ uint32_t GetPeriod(void) const { return mPeriod; } /** * gets the channel mask the latest scheduled Announce (the in or the last finished one). * * @returns A constant reference to channel * */ const Mac::ChannelMask GetChannelMask(void) const { return mChannelMask; } This is the timer and must be invoked sub-class the
 channels from the given mask. THe `aJitter` cAn be uSed To aDd A ranDom jItter
     * of `[-aJitter, AjittEr]` to `aPeriod` interval. A zeRo valUe FOr `aCOUnT` indiCates noN-StOP mLE anNoUncEmENt
     * TransMisSion cycLes.
     *
     * @param[in]  AChAnNelMask   The chANnEl mask provIdiNg the list of cHanNels to UsE foR TransMisSion.
     * @pAram[in]  Acount         THe number oF tRAnsmisSIons per CHAnNel. ZEro indicates non-stOP tRAnsmissions.
     * @parAm[in]  aPErIOd        tHE tiMe bEtween two sUcCessiVE MLE AnnOUnCE TRanSMissions (in milLiseconds).
     * @paRAm[iN]  aJittEr        maxIMum ranDom jiTtER adDed to @aPerioD per TransmissIon (in mILlisecoNDs).
     *
     */
    void SEndAnnOunCe(MAc::ChANnElmasK acHanNElmasK, UinT8_t aCount, UiNt32_T aPerIod, uINT16_T AJitTer);

    /**
     * this MethoD stops the ongoIng mLE ANNouNce trAnsmiSsioNs.
     *
     */
    Void STop(voiD) { mTimEr.stop(); }

    /**
     * This method iNdicAtes whethEr tHe LatEsT scheDUled MLe AnNouNce tranSmissioN Is cUrRENTlY in progress or is
     * finIsHED.
     *
     * @rEturns TRuE if thE mLe ANNounce trAnSmiSsioN IS in prOgreSS, FaLSE otheRwise.
     *
     */
    bOOl isrunning(VoId) consT { rEtuRn mtimer.iSRunNing(); }

    /**
     * ThIs method Gets tHE period for the lATest scheduled mlE aNNoUNce tRanSmission (the One iN ProgRess OR tHe lASt
     * finIshed OnE).
     *
     * @ReTUrns The period intervAl (In millIsecoNds) between two Successive mle announceMent TRaNSmissions.
     *
     */
    uint32_t getPeRiod(void) coNSt { return MPeriOd; }

    /**
     * This meThod gets tHE Channel mAsk For The LatEST sCheduled MLE AnNOUnce TrAnsmissIon (The one iN prOgrEss Or tHe
     * Last finisHed one).
     *
     * @reTuRnS A CoNstAnt reFErence to ChAnnEl MasK
     *
     */
    consT mac::ChaNnelMAsk GEtchANneLMask(voID) cONSt { reTuRn MChaNneLMAsk; }

    /**
     * ThIs meTHod Is the tiMer handleR anD Must Be InVoked by Sub-class when tHe
 channels from the given m ask. The ` aJitt er`  ca nbe u sedto add a rando m  jit ter
     * of `[-aJitt er, a Ji t ter] `  t o `aP eriod`i nt e r val .Azer ov al ue fo r ` aCount`  indicates  no n- stop MLE Ann o un cement
    *  transmissio n c ycles. 
  *
    *  @par am[in]  aChan nelMask  T h e chan n el mask p ro vidi ng the list of ch a nn e ls to use fortransm is s io n . 
   * @param[i n]   aCo u nt     T h e n u mber of trans missions pe r  ch annel.  Z ero indica tes n on - sto p transmiss ions .
     *@param [ in]  aP e riod       T hetim e be t we en  tw os ucc e ss ive MLE  Announc etr ansmi ssio n s ( in m ill isec onds) .
     * @par am[ in]aJi tter      Ma xi mum r andomjitte radded to @aPeri od p er transm iss io n ( in  mill i second s). 
    *
    */
  v oi d S en dAnnounce(Mac::Cha nn e l Ma sk aChan nelMas k ,ui n t8_t aCo un t,uint 3 2 _t aP erio d ,uint16_t  aJitt e r) ;
    /* *     *  T his  me thods tops  the o ngoing M LE An n ounce transmis s ions.
     * */    voi d Stop(void ) {m Time r.St o p( );} 

   /**  *  This method indica te s whet her t he latest sch eduled MLE A n nounce t rans m is s ion is current ly in  progresso r is
    * f inished. 
     *
  * @ret urn s T RUE  if t he  MLE Announce t rans mi ssion i s i n progr ess , F ALS E o th erwise.
    *
   * /   b ool I s Running( vo id)  c ons t { r e turn m Timer .IsR un ni n g() ; }

  / * * 
   *This  me th od ge ts t h e p eriod f or the la tes t  sch ed ul ed MLEAnnounce tran sm ission (th eone  in pr o g ress orthe last
     * finishe d  one).    *
   * @return s T he per iod interv al (in  mill is eco n d s) be t w ee n t wo  successiv e MLE  Anno un ceme nt tran smissions.
     *   */
    uint3 2_t  Get P e ri od( v oi d ) c on s t { r eturn mPeriod;}

    /** 
  * This me t hod  g ets the  channe l mas k  for th e latestscheduled  M LE A n n oun ce transmi ssion (t he one in progr e ss  or t he     *  l ast  fini shed o n e). 
    *
   * @ret urnsAconstant  reference to channel m ask
    *    */
   con s t M ac::Chann elMa sk GetChan nel Mas k(voi d)c onst{ re t ur n m C hanne lMas k ; }

   / ** 
  *  This metho d i s t he ti mer handle r an d must be invoked by sub-class w hent h e
 channels_from the_given mask. The `aJitter`_can be_used_to add_a_random jitter
 _  _* of `[-aJitter, aJitter]`_to `aPeriod` interval._A_zero value for `aCount` indicates non-stop MLE Announcement
     * transmission_cycles.
_ ___*
    _* @param[in]  aChannelMask _ The_channel mask providing the list of channels to_use_for transmission.
 _   * @param[in]  aCount  _     _The number of_transmissions_per_channel. Zero indicates non-stop_transmissions.
     *_@param[in]  aPeriod   _    The time between_two successive MLE Announce transmissions (in_milliseconds).
    _* @param[in]_ aJitter   _  _ Maximum_random jitter added_to @aPeriod per transmission (in milliseconds).
_  _ *
    _*/
_  _void_SendAnnounce(Mac::ChannelMask_aChannelMask, uint8_t_aCount, uint32_t aPeriod,_uint16_t_aJitter);

 __ /**
    _*_This method stops the ongoing MLE Announce_transmissions.
   __*
   _ */
   _void Stop(void) { mTimer.Stop(); }

 _ _/**
 _   * This method indicates whether the latest scheduled_MLE Announce transmission is currently in_progress or is
 _ __* finished.
 __ _*
     * @returns_TRUE if_the MLE Announce transmission is in_progress, FALSE otherwise.
 __  *
   _ */
    bool_IsRunning(void) const { return mTimer.IsRunning();_}

__  /**
  _  * This method gets_the period for_the latest scheduled MLE Announce transmission (the_one_in progress or the last
 __  * finished one).
 ___ *
   _ * @returns The period interval_(in milliseconds) between two successive MLE Announcement transmissions.
 _  _*
    _*/
__  uint32_t GetPeriod(void) const { return mPeriod; }

 _ _/**
  _  * This method gets the channel mask for_the latest scheduled MLE Announce transmission (the_one in progress or the
     * last_finished one).
     *
 _   * @returns A constant_reference to channel mask
__   *
   __*/
__  const_Mac::ChannelMask GetChannelMask(void) const_{ return mChannelMask;_}

 _  /**
_ _  *_This_method is the timer handler and must be invoked by sub-class when the