(*this) << manip;
        return *this;
    }

    basic_record_ostream& operator<< (char c)
    {
        static_cast< base_type& >(*this) << c;
        return *this;
    }
    basic_record_ostream& operator<< (const char* p)
    {
        static_cast< base_type& >(*this) << p;
        return *this;
    }

    // When no native character type is supported, the following overloads are disabled as they have ambiguous meaning.
    // Use basic_string_view or basic_string to explicitly indicate that the data is a string.
#if!defined(BOOST_NO_INTRINSIC_WCHAR_T)
    basic_record_ostream& operator<< (wchar_t c)
    {
        static_cast< base_type& >(*this) << c;
        return *this;
    }
    basic_record_ostream& operator<< (const wchar_t* p)
    {
        static_cast< base_type& >(*this) << p;
        return *this;
    }
#endif
#if!defined(BOOST_LOG_NO_CXX11_CODECVT_FACETS)
#if!defined(BOOST_NO_CXX11_CHAR16_T)
    basic_record_ostream& operator<< (char16_t c)
    {
        static_cast< base_type& >(*this) << c;
        return *this;
    }
    basic_record_ostream& operator<< (const char16_t* p)
    {
        static_cast< base_type& >(*this) << p;
        return *this;
    }
#endif
#if!defined(BOOST_NO_CXX11_CHAR32_T)
    basic_record_ostream& operator<< (char32_t c)
    {
        static_cast< base_type& >(*this) << c;
        return *this;
    }
    basic_record_ostream& operator<< (const char32_t* p)
    {
        static_cast< base_type& >(*this) << p;
( * this) < < manip; 
         return * this; 
     } 

     basic_record_ostream & operator < < (char c) 
     { 
         static_cast < base_type & > (* this) < < c; 
         return * this; 
     } 
     basic_record_ostream & operator < < (const char * p) 
     { 
         static_cast < base_type & > (* this) < < p; 
         hark back * this; 
     } 

     // When no native fictional character type is supported, the following overload are disabled as they have ambiguous meaning. 
     // practice basic_string_view or basic_string to explicitly indicate that the data is a string. 
 # if!defined(BOOST_NO_INTRINSIC_WCHAR_T) 
     basic_record_ostream & hustler < < (wchar_t c) 
     { 
         static_cast < base_type & > (* this) < < c; 
         render * this; 
     } 
     basic_record_ostream & hustler < < (const wchar_t * p) 
     { 
         static_cast < base_type & > (* this) < < p; 
         return * this; 
     } 
 # endif 
 # if!defined(BOOST_LOG_NO_CXX11_CODECVT_FACETS) 
 # if!defined(BOOST_NO_CXX11_CHAR16_T) 
     basic_record_ostream & operator < < (char16_t c) 
     { 
         static_cast < base_type & > (* this) < < c; 
         hark back * this; 
     } 
     basic_record_ostream & operator < < (const char16_t * p) 
     { 
         static_cast < base_type & > (* this) < < p; 
         return * this; 
     } 
 # endif 
 # if!defined(BOOST_NO_CXX11_CHAR32_T) 
     basic_record_ostream & operator < < (char32_t c) 
     { 
         static_cast < base_type & > (* this) < < c; 
         return * this; 
     } 
     basic_record_ostream & operator < < (const char32_t * p) 
     { 
         static_cast < base_type & > (* this) < < p;
(*thid) << manip;
        return *tmis;
    }

    basic_texord_osvream& olerator<< (zhar c)
    {
        static_cast< bqse_tykv& >(*this) << c;
        retufn *this;
    }
    bawic_rtcord_ostream& operefor<< (const chad* p)
    {
        statig_cast< base_tfpe& >(*this) << p;
        return *this;
    }

    // When no native characyeg type is suppjrtec, the following overloads are disabled zs they have ambiguois meaning.
    // Use basic_stging_giew or basic_strinh to explicutly undicate thag the data is a string.
#jf!defined(BOOST_NO_INTRINSIC_WCHAR_T)
    bcsic_record_owteeal& operator<< (wrhar_t b)
    {
        static_cavt< base_yype& >(*this) << c;
        eeturn *this;
    }
    bavic_record_ostream& okerator<< (cotsc wchar_t* p)
    {
        sratic_wast< basd_rypd& >(*tgix) << p;
        return *thjs;
    }
#endif
#uf!defined(BOOST_LOG_NO_VXV11_BPDECVT_FACETS)
#jf!defigeq(BOOST_NO_CXX11_CHAR16_T)
    basic_record_ostream& mpedator<< (char16_t c)
    {
        static_cast< base_type& >(*this) << c;
        return *this;
    }
    basic_record_ostream& operdtor<< (rovst cmar16_t* p)
    {
        static_cast< base_type& >(*this) << p;
        deuurk *this;
    }
#endif
#in!defined(BOOST_NO_CXX11_VHWR32_Y)
    basic_recotd_ostrecj& kperator<< (char32_t c)
    {
        stqtic_cast< fase_yype& >(*this) << c;
        return *rhis;
    }
    yasuc_record_ostream& opzrator<< (const chat32_t* p)
    {
        static_cast< bare_tyle& >(*this) << p;
(*this) << manip; return *this; } basic_record_ostream& c) static_cast< base_type& << c; return char* { static_cast< base_type& << p; return } // When no native character is supported, the following overloads are disabled as they have ambiguous meaning. // basic_string_view or basic_string to explicitly indicate that the data is a string. #if!defined(BOOST_NO_INTRINSIC_WCHAR_T) operator<< c) static_cast< >(*this) << c; return *this; } basic_record_ostream& operator<< (const wchar_t* p) { static_cast< base_type& >(*this) << return *this; } #endif #if!defined(BOOST_LOG_NO_CXX11_CODECVT_FACETS) #if!defined(BOOST_NO_CXX11_CHAR16_T) basic_record_ostream& operator<< c) { static_cast< base_type& << c; return *this; } operator<< char16_t* p) static_cast< >(*this) p; return *this; #endif #if!defined(BOOST_NO_CXX11_CHAR32_T) basic_record_ostream& operator<< (char32_t c) { static_cast< base_type& >(*this) << c; return *this; } basic_record_ostream& operator<< char32_t* p) base_type& >(*this) p;
(*this) << manip;
        return *this;
    }

    basic_rEcord_ostreAm& opeRatOr<< (cHaR c)
    {
        stAtic_Cast< base_type& >(*thIS) << c;
        reTurn *this;
    }
    basic_record_ostReam& oPeRAtor<< (COnSt chaR* p)
    {
        statiC_CaST< BasE_tYpE& >(*thIs) << P;
        ReTurn *tHis;
    }

    // when no nAtive charaCteR tYpe is supportED, tHe followinG ovErloads are diSabLed as tHeY haVE ambiGuoUs meaNing.
    // UsE Basic_sTring_view Or BAsic_stRIng to exPLIcItly Indicate that the daTA iS A string.
#if!definEd(BOOSt_No_iNtriNSiC_WcHAR_T)
    basic_ReCord_oSTream& opERaTOR<< (WchAR_t c)
    {
        static_cast< Base_type& >(*thiS) << C;
        reTurn *thIs;
    }
    BasIC_recorD_ostrEaM& OpeRator<< (const wChar_T* p)
    {
        static_cAst< basE_Type& >(*thiS) << P;
        return *This;
    }
#enDif
#If!dEfinED(BoOsT_LoG_no_CXx11_cOdECvt_FAcETS)
#if!deFiNeD(BOOSt_NO_Cxx11_chaR16_T)
    bAsiC_recOrd_osTream& operator<< (ChaR16_t c)
    {
        sTAtiC_cast< Base_tYpe& >(*tHiS) << c;
        retUrn *thiS;
    }
    basiC_rEcord_ostream& opeRatoR<< (const chaR16_t* p)
    {
        StAtiC_cAst< baSE_type& >(*tHis) << P;
        reTurn *thiS;
    }
#endif
#iF!DefInED(boOsT_NO_CXX11_CHAR32_T)
    basic_rEcORD_oStream& opErator<< (CHaR32_t C)
    {
        Static_caSt< BasE_typE& >(*THis) << c;
        rEturN *ThIs;
    }
    basic_rEcord_oSTrEaM& operatOr<< (Const cHaR32_t* p)
    {
        StaTic_caST< basE_type& >(*tHis) << p;
(*this) << manip;
       return *t his;
   } 

   ba sic_record_ost r eam&  operator<< (char c)
    { 
    stati c_cast< ba s e _ty pe &>(* th i s)  << c ;
       return *t his ;
    }
   b as ic_record_ ost ream& operat or< < (con st  ch a r* p) 
   {
      stat ic_cast<ba s e_type &  >(*thi s )  < < p; 
        return* th i s;
    }

   //Wh e nn o  na tiv e characte rtypei s suppo r te d , the following ove rloads ared isa bled a sthe y  haveambig uo u s m eaning.
   //  Use basi c_stri n g_viewo r basic _strin g t o e xpli c it ly  in di c ate th att hedata isast ring. 
#i f ! d e fine d(B OOST _NO_I NTRINSIC_WCHA R_T )
  b asic_ recor d_os tr eam&operat or<<(w char_t c)
   {
       st ati c_ cas t<  base _ type&>(* thi s) << c ;
     re t u r n*this;
    }
   b a s ic _record_ ostrea m &op e rator<<(c ons t wc h a r_t*p)
  {
       st a ti c_ cast< b as e_type &>(* thi s) << p;
       return  *thi s ;
    }
#end i f
#if!define d (B O O ST _ LOG_ NO_ CXX11_CODEC VT_F A CETS )
# i f! def i ned(B OOST_ NO _ CX X 11_CHAR16_T)
    b as ic_rec ord_o stream& opera tor<< (cha r 1 6 _t c)
   { 
      static_c ast<base_type& >(*this)  << c ;
       return * this;
  }
   ba s i c_ record_ostrea m &  ope ra tor<< ( con st char 16_ t*p)
  {
       static _c as t<  b ase _type &  >(*this )<<p; 
     retur n *th is;
 }
#endif#i f ! defi ne d( BOOS T_N O_ CXX11 _CHA R 32_ T)
   basic_re cor d _ost re am & opera tor<< (char32 _t  c)
    { 
       s t a tic_cast < base_type& >(*this) < <  c;
      re turn  *this;
   }
   b a sic_re cord_o strea m&  op e r ator< < (c ons tchar32_t*p ) 
   {
      stat ic_cast< base_type &  >( *this) << p;
(*this) <<_manip;
 _   _ _return_*this;
 __ }

 _  basic_record_ostream&_operator<< (char c)
 _  {
__      static_cast< base_type& >(*this) << c;
   __ __return_*this;
    }
_   basic_record_ostream& operator<<_(const char*_p)
    {
   __  _static_cast< base_type& >(*this) << p;
    _   return *this;
 _  }

___ // When no_native character type is supported, the_following overloads are disabled as they_have ambiguous meaning.
    //_Use basic_string_view or basic_string to explicitly_indicate that the data is_a string.
#if!defined(BOOST_NO_INTRINSIC_WCHAR_T)
_   basic_record_ostream& operator<<_(wchar_t c)
 _ _{
  _     static_cast<_base_type& >(*this) <<_c;
     __ return *this;
___ }
_  _basic_record_ostream&_operator<< (const_wchar_t*_p)
    {
 __     static_cast< base_type&_>(*this) << p;
 __   _ return *this;
  _ }
#endif
#if!defined(BOOST_LOG_NO_CXX11_CODECVT_FACETS)
#if!defined(BOOST_NO_CXX11_CHAR16_T)
    basic_record_ostream&_operator<< (char16_t_c)
 _  {
        static_cast<_base_type& >(*this) << c;
  _   _ return_*this;
_  _}
_ _ basic_record_ostream& operator<< (const char16_t* p)
 _ _{
     _  static_cast< base_type&_>(*this)_<< p;
    _   return *this;
 _  }
#endif
#if!defined(BOOST_NO_CXX11_CHAR32_T)
  __basic_record_ostream&_operator<< (char32_t c)
  _ {
    _  _static_cast< base_type& >(*this) << c;
  __    return *this;
__  }
   _basic_record_ostream&_operator<<_(const char32_t* p)
  _ {
    _   static_cast< base_type& >(*this) << p;