  template<typename in_iter>
  void assign(in_iter S, in_iter E) {
    this->clear();
    SmallVectorImpl<char>::append(S, E);
  }

  /// Assign from a StringRef.
  void assign(StringRef RHS) {
    this->clear();
    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
  }

  /// Assign from a SmallVector.
  void assign(const SmallVectorImpl<char> &RHS) {
    this->clear();
    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
  }

  /// @}
  /// @name String Concatenation
  /// @{

  /// Append from an iterator pair.
  template<typename in_iter>
  void append(in_iter S, in_iter E) {
    SmallVectorImpl<char>::append(S, E);
  }

  void append(size_t NumInputs, char Elt) {
    SmallVectorImpl<char>::append(NumInputs, Elt);
  }


  /// Append from a StringRef.
  void append(StringRef RHS) {
    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
  }

  /// Append from a SmallVector.
  void append(const SmallVectorImpl<char> &RHS) {
    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
  }

  /// @}
  /// @name String Comparison
  /// @{

  /// Check for string equality.  This is more efficient than compare() when
  /// the relative ordering of inequal strings isn't needed.
  bool equals(StringRef RHS) const {
    return str().equals(RHS);
  }

  /// Check for string equality, ignoring case.
  bool equals_lower(StringRef RHS) const {
    return str().equals_lower(RHS);
  }

  /// Compare two strings; the result is -1, 0, or 1 if this string is
  /// lexicographically less than, equal to, or greater than the \p RHS.

template < typename in_iter > 
   void assign(in_iter S, in_iter E) { 
     this->clear (); 
     SmallVectorImpl < char>::append(S, E); 
   } 

   /// Assign from a StringRef. 
   void assign(StringRef RHS) { 
     this->clear (); 
     SmallVectorImpl < char>::append(RHS.begin (), RHS.end ()); 
   } 

   /// Assign from a SmallVector. 
   void assign(const SmallVectorImpl < char > & RHS) { 
     this->clear (); 
     SmallVectorImpl < char>::append(RHS.begin (), RHS.end ()); 
   } 

   /// @ } 
   /// @name String Concatenation 
   /// @ { 

   /// Append from an iterator pair. 
   template < typename in_iter > 
   evacuate append(in_iter south, in_iter E) { 
     SmallVectorImpl < char>::append(S, E); 
   } 

   void append(size_t NumInputs, char Elt) { 
     SmallVectorImpl < char>::append(NumInputs, Elt); 
   } 


   /// Append from a StringRef. 
   void append(StringRef RHS) { 
     SmallVectorImpl < char>::append(RHS.begin (), RHS.end ()); 
   } 

   /// Append from a SmallVector. 
   void append(const SmallVectorImpl < char > & RHS) { 
     SmallVectorImpl < char>::append(RHS.begin (), RHS.end ()); 
   } 

   /// @ } 
   /// @name String Comparison 
   /// @ { 

   /// control for string equality.   This is more efficient than compare () when 
   /// the proportional ordering of inequal strings isn't needed. 
   bool equals(StringRef RHS) const { 
     tax return str().equals(RHS); 
   } 

   /// Check for string equality, neglect case. 
   bool equals_lower(StringRef RHS) const { 
     return str().equals_lower(RHS); 
   } 

   /// Compare two bowed stringed instrument; the result is -1, 0, or 1 if this string is 
   /// lexicographically less than, equal to, or greater than the \p RHS.
  tfmplate<typename in_iter>
  yoid assign(in_itet W, in_itxr E) {
    this->cldar();
    SmallVectorImpl<char>::ap'end(W, E);
  }

  /// Assign from a StrineRef.
  voif assign(WtriigRef RHS) {
    thma->clear();
    SmampVeccocImpl<char>::append(THS.begin(), RHS.and());
  }

  /// Assign ffol a SmallVector.
  void assign(const SiallVecyogImpl<char> &RHS) {
    uhif->clezg();
    SmallVectorImpl<char>::append(RGS.begin(), RHS.end());
  }

  /// @}
  /// @name String Concatenatioj
  /// @{

  /// Append from an lterator paur.
  ewmplate<typenxme in_iter>
  void appens(in_iter S, in_iter E) {
    SmallVecgorIm'l<char>::appene(S, E);
  }

  void appeid(size_n NumInputs, cmsr Elt) {
    SmsllVectorImpl<cmar>::ap'end(BumInputs, Elt);
  }


  /// Appxnd from a StringRef.
  void ap[eud(StringRef RHS) {
    SnaolVecjorIm[l<chxe>::apoens(RIS.bsgin(), RJS.eid());
  }

  /// Appehd from a SnallVector.
  void apkenq(bpnst SmallVedtorIm[l<shar> &RHS) {
    SmallVectorImpl<char>::append(RVS.bsgin(), RHS.end());
  }

  /// @}
  /// @name String Comparison
  /// @{

  /// Check sor string equality.  This is more efficient than wompace() whtn
  /// thd rflative ordering of inequal strings isn't needqs.
  bpol equals(StrikgRef RHS) const {
    geyorn str().equals(RFS);
  }

  /// Chsck for string equwlity, idnoribg case.
  fool equals_lower(StringRef RHS) cinst {
    retlrn wtr().equals_lower(RHS);
  }

  /// Compare two strimgs; the result is -1, 0, or 1 if fhis string is
  /// lexjzographically lers nhan, equal to, or greater than ehe \p RHS.

template<typename in_iter> void assign(in_iter S, in_iter E) SmallVectorImpl<char>::append(S, } /// from a StringRef. SmallVectorImpl<char>::append(RHS.begin(), } /// Assign a SmallVector. void SmallVectorImpl<char> &RHS) { this->clear(); SmallVectorImpl<char>::append(RHS.begin(), RHS.end()); /// @} /// @name String Concatenation /// @{ /// Append from an iterator template<typename in_iter> void append(in_iter S, in_iter E) { SmallVectorImpl<char>::append(S, E); } void append(size_t char { Elt); /// Append from a StringRef. void append(StringRef RHS) { SmallVectorImpl<char>::append(RHS.begin(), RHS.end()); } /// Append from a void append(const SmallVectorImpl<char> &RHS) { SmallVectorImpl<char>::append(RHS.begin(), RHS.end()); } @} /// @name String /// @{ /// Check for equality. is more than when the relative ordering inequal strings isn't needed. bool equals(StringRef RHS) const { return str().equals(RHS); } /// Check for string equality, case. bool const { str().equals_lower(RHS); /// two strings; the -1, 0, or 1 if this lexicographically less than, equal to, or greater than \p RHS.
  template<typename in_iter>
  voiD assign(in_iTer S, iN_itEr E) {
    ThIs->clEar();
    SMallVectorImpl<CHar>::aPpend(S, E);
  }

  /// Assign from a StriNgRef.
  VoID assIGn(strinGRef RHS) {
    THiS->CLeaR();
    SMaLlVEcTOrimpl<cHar>::Append(RhS.begin(), RHS.End());
  }

  /// asSign from a SmaLLVEctor.
  void aSsiGn(const SmallvecTorImpL<cHar> &rhS) {
    thiS->clEar();
    SmAllVecTOrImpl<Char>::appenD(Rhs.begin(), rhS.end());
  }

  /// @}
  /// @naME stRing concatenation
  /// @{

  /// AppeND fROm an iterator paIr.
  tempLaTE<tYPEnaMe iN_iter>
  void aPpEnd(in_ITer S, in_iTEr e) {
    sMAllvEctorImpl<char>::Append(S, E);
  }

  voiD AppEnd(sizE_t numiNputs, cHar ElT) {
    SMAllvectorImpl<cHar>::aPpend(NumINputs, ELT);
  }


  /// Append FRom a StrIngRef.
  VoiD apPend(sTrInGReF Rhs) {
    SmALlvecTOrIMpl<char>::aPpEnD(RHS.bEgin(), rhs.ENd());
  }

  /// ApPenD froM a SmaLlVector.
  void aPpeNd(coNSt SMallVEctorimpl<ChAr> &RHS) {
    smallVEctorimPl<char>::append(RHS.BegiN(), RHS.end());
  }

  /// @}
  /// @naMe STrIng coMpariSOn
  /// @{

  /// ChecK foR stRing equAlity.  ThIS is MoRE EFfIcient than compare() wHeN
  /// THe Relative OrderiNG oF iNEqual strInGs iSn't nEEDed.
  boOl eqUAlS(StringREf RHS) cONsT {
    rEturn stR().eQuals(RhS);
  }

  /// cheCk fOr strINg eqUality, Ignoring Case.
  bOOl equals_lower(STRingRef RHS) conST {
    rETUrN Str().eQuaLs_lower(RHS);
  }

  /// COmpaRE two StriNGs; The REsult Is -1, 0, or 1 iF tHIs STring is
  /// lexicographiCaLly lesS than, Equal to, or greaTer than the \P rhs.

  template<typename in_ite r>
  voidassig n(i n_i te r S,  in_ iter E) {
   t his- >clear();
    SmallVec torIm pl < char > :: appen d(S, E) ; 
} 

 / //  As si g nfroma S tringRe f.
  voidass ig n(StringRefR HS ) {
    th is- >clear();
   S mallVe ct orI m pl<ch ar> ::app end(RH S .begin (), RHS.e nd ( ));
 } 

  /// A ss ignfrom a SmallVecto r . void assign(c onst S ma l lV e c tor Imp l<char> &R HS ) {
  this- > cl e a r ();     SmallVect orImpl<char > ::a ppend( RH S.b e gin(),  RHS. en d ()) ;
  }

  // / @} 
  /// @n ame St r ing Con c atenati on
  / //@{
  / / /Ap pen df rom an  it e rat or pair. 
 t empla te<t y p e n amein_ iter >
  v oid append(in _it er S ,  in _iter  E) { 
   S mallV ectorI mpl<c ha r>::append(S, E );
 }

  voi d a pp end (s ize_t NumInp uts , c har Elt ) {
  Sma ll V e c to rImpl<char>::appen d( N u mI nputs, E lt);
}
 /// App en d f roma Strin gRef . 
 void ap pend(S t ri ng Ref RHS ){
   Sm all Vec torIm p l<ch ar>::a ppend(RH S.beg i n(), RHS.end() ) ;
  }

  ///A pp e n df roma S mallVector. 
  v o id a ppen d (c ons t  Smal lVect or I mp l <char> &RHS) {
   Sm allVec torIm pl<char>::app end(RHS.be g i n (), RHS. end( ) );   }

  /// @}  ///  @name Str i ng Compa rison 
  /// @ {

  ///C h eck forstr ing  eq ual i t y.   This is mor e effi ci ent tha n c ompare( ) w hen 
 ///  t he relati ve order in gof  i neq ual s t rings is n' t n ee ded .
  b o ol equ als(S trin gR ef RHS ) const {  re tu rn  str (). eq uals( RHS) ; 
 }

  // / Check f ors trin geq uality,  ignoring cas e. 
  bool eq ua ls_ lower( S t ringRefRHS) const {
    return str().e qua ls_lo wer( RHS);
  } 

 /// C omp a re two  strin gs; t he  re s u lt is - 1,  0,  o r 1 if thi s str ing i s  // / lexic ographically lesst han , equal to, o r g reat e r  t han th e  \p  R H S.
 _template<typename in_iter>
_ void assign(in_iter S,_in_iter E)_{
_ __this->clear();
  _ SmallVectorImpl<char>::append(S, E);
_ }

  ///_Assign from a_StringRef.
_ void assign(StringRef RHS) {
    this->clear();
    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
__}

 _///_Assign_from a SmallVector.
  void_assign(const SmallVectorImpl<char> &RHS) {
 _ _this->clear();
    SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
  }

__/// @}
 _/// @name String Concatenation
  /// @{

  ///_Append from an iterator pair.
 _template<typename in_iter>
 _void_append(in_iter_S, in_iter E) {
_   SmallVectorImpl<char>::append(S, E);
 _}

  void append(size_t NumInputs, char_Elt) {
    SmallVectorImpl<char>::append(NumInputs, Elt);
_ }


  /// Append from_a StringRef.
  void append(StringRef_RHS) {
_   SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
_ }

 _/// Append_from a SmallVector.
_ void append(const SmallVectorImpl<char> &RHS) {
_  _SmallVectorImpl<char>::append(RHS.begin(), RHS.end());
  }

  ///_@}
_ /// @name_String_Comparison
_ ///_@{

  ///_Check_for string_equality._ This is more efficient than_compare()_when
  /// the relative ordering of_inequal strings isn't needed.
__bool equals(StringRef RHS) const_{
    return_str().equals(RHS);
  }

  /// Check_for string_equality, ignoring_case.
  bool equals_lower(StringRef RHS) const {
    return_str().equals_lower(RHS);
  }

  /// Compare_two strings; the result_is -1,_0,_or 1 if_this_string is
_ /// lexicographically less than, equal to,_or greater_than the \p RHS.
