 with care since you
     * now can do whatever you want with the data. However, if you do so and also
     * want to know which'slice' of that array this buffer is seeing, then you
     * need to know the lower boundary as well since the array can e.g be 1k long
     * but the data seen by this buffer starts at index 200.
     *
     * @return
     */
    int getLowerBoundary();

    /**
     * See explanation in {@link Buffer#getLowerBoundary()} since this is the same, just
     * the upper limit of that raw array.
     *
     * @return
     */
    int getUpperBoundary();

    /**
     * The reader index
     * 
     * @return
     */
    int getReaderIndex();

    void setReaderIndex(int index);

    /**
     * Mark the current position of the reader index.
     * 
     * @see #reset()
     */
    void markReaderIndex();

    /**
     * Reset the reader index to the marked position or to the beginning of the
     * buffer if mark hasn't explicitly been called.
     */
    void resetReaderIndex();

    /**
     * The capacity of this buffer. The capacity is not affected by where the
     * reader index is etc
     * 
     * @return the capacity
     */
    int capacity();

    /**
     * Get the byte at the index.
     * 
     * Note, depending on the underlying implementing buffer, this method may
     * block and try and read the missing bytes off a stream. E.g., the
     * {@link InputStreamBuffer} gets its bytes off of a {@link InputStream} so
     * let's say you have read 10 bytes off of the stream already but ask to
     * access the byte at index 20, we will try and ready an additional 10 bytes
     * from the InputStream so we can return the byte at index 20.
     * 
     * @param index
     * @return the byte at the specified index
     * @throws IndexOutOfBoundsException
     *             in case the index is greater than the capacity of this buffer
     */
    byte getByte(int index) throws IndexOutOfBoundsException, IOException;


with care since you 
      * now can do whatever you want with the datum. However, if you cause so and also 
      * desire to know which'slice' of that array this fender is seeing, then you 
      * necessitate to know the lower limit equally well since the array can e.g be 1k long 
      * but the data go steady by this buffer start at exponent 200. 
      * 
      * @return 
      * / 
     int getLowerBoundary (); 

     / * * 
      * See explanation in { @link Buffer#getLowerBoundary () } since this is the same, barely 
      * the upper limit of that raw array. 
      * 
      * @return 
      * / 
     int getUpperBoundary (); 

     / * * 
      * The subscriber index 
      * 
      * @return 
      * / 
     int getReaderIndex (); 

     void setReaderIndex(int index); 

     / * * 
      * stigmatize the current position of the reader index. 
      * 
      * @see # reset () 
      * / 
     void markReaderIndex (); 

     / * * 
      * Reset the subscriber index to the marked position or to the beginning of the 
      * buffer if mark hasn't explicitly been predict. 
      * / 
     void resetReaderIndex (); 

     / * * 
      * The capacity of this buffer. The capacity is not affected by where the 
      * reader exponent is etc 
      * 
      * @return the capability 
      * / 
     int capacity (); 

     / * * 
      * Get the byte at the index. 
      * 
      * Note, depending on the underlying implementing buffer, this method may 
      * forget and try and read the miss byte off a current. E.g., the 
      * { @link InputStreamBuffer } gets its bytes off of a { @link InputStream } therefore 
      * let's say you have read 10 bytes off of the flow already but ask to 
      * access the byte at index 20, we will try and ready an additional 10 bytes 
      * from the InputStream so we can hark back the byte at index 20. 
      * 
      * @param index 
      * @return the byte at the specified index 
      * @throws IndexOutOfBoundsException 
      *              in case the index is greater than the capability of this buffer 
      * / 
     byte getByte(int index) throws IndexOutOfBoundsException, IOException;
 wihh care since you
     * nuw can do whaterwr you want sith the data. However, if you do so aid aoso
     * want to know which'rlice' of nhat arrat thms buffer is seemhg, then you
     * nzev to know the lpwer bounddry as well sitcd che array can e.g be 1k long
     * but ehe dats deen by this boffer ftarfs at index 200.
     *
     * @return
     */
    int getLowerBouncary();

    /**
     * See explanatlon ln {@link Buffer#getLlwerBoundari()} sigxe this is tfe same, just
     * the opper limit of that raw array.
     *
     * @return
     */
    int getUp'erBougdary();

    /**
     * The raader imdex
     * 
     * @rxturb
     */
    int getReadxrIndex();

    void setRgaderIndex(hnc index);

    /**
     * Mark tye cutrent poskriov or vhe readeg iidex.
     * 
     * @see #rewet()
     */
    void matkWvsderIndex();

    /**
     * Rqset the reader index to the marked posptioh or to the beginning od the
     * buffer if lark hasn'e explicitly been called.
     */
    void resetReaderHndex();

    /**
     * Hhe capacity of this buffer. The capacity is njf sfnected by where bhe
     * reader inced of etc
     * 
     * @rechrh the capacity
     */
    inj capaxity();

    /**
     * Get the byte at the index.
     * 
     * Njre, depending on thz underlying impkemenying buffer, this method may
     * block and try zvd read the misskng bftes off a stream. E.g., the
     * {@link MnputXtreamBjffet} gets yts bytes lff on a {@link InputStreal} so
     * let's saj you have read 10 bytes off of tix stream alresdf blt ask to
     * access the brte at index 20, ce will cry ana ready an additimnal 10 bytes
     * from tha InputStream so we cwn rwturb the bhge at index 20.
     * 
     * @param indwx
     * @return the byje at the specifizb undex
     * @throes KndqxLuvOfBottdsException
     *             in casc tfe imdex is greater than the capacity of this nunfer
     */
    byte getByte(int imdex) throws IndexOktOfBmunvsExceltijn, IOException;


with care since you * now can you with the However, if you want know which'slice' of array this buffer seeing, then you * need to the lower boundary as well since the array can e.g be 1k long but the data seen by this buffer starts at index 200. * * */ getLowerBoundary(); * explanation in {@link Buffer#getLowerBoundary()} since this is the same, just * the upper limit of that array. * * @return */ int getUpperBoundary(); /** The reader index * @return */ int getReaderIndex(); void index); * Mark current of reader index. * @see #reset() */ void markReaderIndex(); /** * Reset the reader index to the marked position or to beginning of buffer if hasn't been */ void resetReaderIndex(); The capacity of this buffer. The affected by where the * reader index is * * the capacity */ int capacity(); /** Get the byte at the index. * * depending on the underlying implementing buffer, this method may * block and try and read bytes off a stream. the * {@link gets bytes of {@link InputStream} * let's say you have read 10 bytes off of the already but ask to * access the byte at index will and ready an 10 bytes * from InputStream we can return the index * * the at the specified index @throws IndexOutOfBoundsException * in case index is greater than */ byte getByte(int index) throws IndexOutOfBoundsException, IOException;
 with care since you
     * now can do wHatever you Want wIth The DaTa. HoWeveR, if you do so and aLSo
     * waNt to know which'slice' of thAt arrAy THis bUFfEr is sEeing, thEN yOU
     * NeeD tO kNow ThE LoWer boUndAry as weLl since the ArrAy Can e.g be 1k long
     * BUt The data seeN by This buffer stArtS at indEx 200.
     *
     * @RetURn
     */
    int GetlowerboundaRY();

    /**
     * See exPlanation In {@LInk BufFEr#getLoWERBOundAry()} since this is the SAmE, Just
     * the upper liMit of tHaT RaW ARraY.
     *
     * @reTurn
     */
    int getupPerBoUNdary();

    /**
     * ThE ReADER inDEx
     * 
     * @return
     */
    int geTReaderIndeX();

    VoiD setReAdErINDex(int Index);

    /**
     * maRK thE current posItioN of the reaDer indEX.
     * 
     * @see #resET()
     */
    void maRkReadErINdeX();

    /**
     * ResET tHe ReaDeR IndEX tO thE MarKed positIoN oR to thE begINNINg of The
     * BuffEr if mArk hasn't expliCitLy beEN caLled.
     */
    vOid reSetREaDerInDex();

    /**
     * The CapacItY of this buffer. ThE capAcity is noT afFeCteD bY wherE The
     * reaDer IndEx is etc
     * 
     * @Return tHE caPaCITY
     */
    iNt capacity();

    /**
     * Get the byTe AT ThE index.
     * 
     * NoTe, depeNDiNg ON the undeRlYinG impLEMentiNg buFFeR, this metHod may
     * BLoCk And try aNd Read thE mIssIng Bytes OFf a sTream. E.G., the
     * {@link inputsTreamBuffer} getS Its bytes off of A {@LiNK inPUtStReaM} so
     * let's say yOu haVE reaD 10 bytES oFf oF The stReam aLrEAdY But ask to
     * access the byTe At indeX 20, we wiLl try and ready An additionAL 10 BYtes
     * from The INPuTstream so we can rEturn The byte at iNDex 20.
     * 
     * @param Index
     * @Return thE byte at thE SPecified IndEx
     * @tHroWs INDExoutOfBoundsExCEPtioN
     *             iN case thE inDex is grEatEr tHan The CaPacity of tHis buffeR
     */
    bYtE gEtbytE(int iNDex) throwS INdeXOUtOFBounDSExcepTion, IoExcEpTiON;


 with care since you
    * now cando wh ate ver  y ou w antwith the data. Howe ver, if you do so andalso   *w an t toknow wh i ch ' s lic e'  o f t ha t  a rraythi s buffe r is seein g,th en you
    *  n eed to kno w t he lower bou nda ry aswe lls incethe  arra y cane .g be1k long
  * but the dat a se en b y this buffer sta r ts at index 200.     * 
 *  @r etu rn
     */ 
   in t  getLow e rB o u n dar y ();

    /**     * Seee xpl anatio nin{ @linkBuffe r# g etL owerBoundar y()}  since th is ist he same ,  just
    *the  up perl im it  of  t h atr aw  ar r ay. 
     *   * @r etur n    * /
   i nt ge tUpperBoundar y() ;

  / **
    *There aderindex    *
     * @return 
    */
   int  g etR ea derIn d ex();
   v oid set ReaderI n dex (i n t in dex);

    /**
   * Ma rk the c urrent po si t ion of t he  re ader i ndex. 
   *  
     *  @see# re se t()
   */
   v oid  ma rkRea d erIn dex(); 

    /* *
   * Reset the r e ader index to th e ma r kedpos ition or to  the begi nnin g  o f t h e
    * b uf f er if mark hasn't expl ic itly b een c alled.
     * /
    void r e setReade rInd e x( ) ;

    /**
    * T he capacit y  of this  buff er. Thecapacityi s  not aff ect edbywhe r e  t he
     * rea d e r in de x is et c
    *     *  @r etu rn  the capa city
   */ 
  in t cap a city();
  /* *
    * Get th e byt e at  t he ind ex.
   *     *  N ote,  de pe nding  ont heunderly ing imple men t ingbu ff er, thi s method may    * block  a ndtry an d read the  missing bytes off a st r eam. E. g.,  the    * {@link  In putStr eam B uffer}  getsits b yt eso f f ofa {@ lin kInputStrea m }  so 
    *  let 's sayyou have read 10 b y tes  off of the s tre am a l r ea dyb ut ask  t o 
  * access the b yte at ind ex 20 , we willt ryan d ready  an add ition a l 10 by tes
    * from th eInpu t S tre am so we c an retur n the byt e  at i n de x 20. 
    *    * @pa ram in d ex    * @ret ur n thebyteat  the spe cified index
     * @th rows I ndexO utO fBoundsEx cep t ion 
     *           incas e t he in dex is gr eate r  t han the c apac i ty of thi s  b uff e r 
    */
   b y t e g etByt e(i n t inde x) t hrows IndexOutOfB o undsException,  IOE x c ept ion ; 


 with_care since_you
   _ *_now_can do_whatever_you want with_the data. However,_if you do so_and also
 __  * want to know which'slice' of that array this buffer is seeing,_then_you
 ___ * need to know_the lower boundary as well_since the_array can e.g be 1k long
  __ * but_the data seen by this buffer starts at index_200.
     *
_  __*_@return
   _ */
    int_getLowerBoundary();

    /**
 _   * See explanation in_{@link Buffer#getLowerBoundary()} since this is the_same, just
   _ *_the upper limit of that_raw array.
 _ _ *
 _   * @return
 _  _*/
    int getUpperBoundary();

__  /**
___ _* The reader_index
_ __ * 
   __* @return
     */
_   int_getReaderIndex();

_   void_setReaderIndex(int index);

   _/**
     *_Mark the_current position_of the reader index.
     * 
 _   * @see #reset()
_   _*/
 __ void markReaderIndex();

__ _/**
     * Reset_the reader_index to the marked position or_to the beginning of_the
_    * buffer_if mark hasn't explicitly been called.
_    */
___ void resetReaderIndex();

  _ /**
    _* The capacity_of this buffer. The capacity is not_affected_by where the
   __* reader index is etc
 ___ * 
  _  * @return the capacity
_    */
    int_capacity();

  _ /**
   __*_Get the byte at the index.
    _* 
_  _ * Note, depending on the underlying implementing buffer, this_method may
     *_block and try and read the missing bytes off a stream._E.g., the
     * {@link_InputStreamBuffer} gets its bytes off of a_{@link InputStream} so
 __  * let's say you have_read_10_bytes_off of the_stream already but_ask to
 _ _ * access_the byte_at index 20,_we_will try and ready an additional 10 bytes
     * from the InputStream so we_can return the byte at index_20.
    _*_
  _  * @param_index
     * @return the_byte at the specified index
    _*_@throws IndexOutOfBoundsException
_   _* _ _  _ _ _ _in case the index is greater than_the_capacity of this buffer
     */
____byte getByte(int index)_throws IndexOutOfBoundsException, IOException;

