自学教程：C++ string_type函数代码示例

			static std::deque<string_type> tokenize(string_type input, string_type br)			{				typename string_type::iterator a,b,c;				std::deque<string_type> tokens;				// std::cerr << "Tokenising string=" << input << " break=" << br << std::endl;				while ( input.length() )				{					a = input.begin();					c = input.end();					typename string_type::size_type e = input.find(br);					if ( e != string_type::npos )					{						b = a+e;						tokens.push_back(string_type(a,b));						input = string_type(b+br.length(),c);					}					else					{						tokens.push_back(input);						input = string_type();					}					// std::cerr << "Pushed token " << tokens.back() << " input now " << input << std::endl;				}				return tokens;			}

 string_type to_string()              const {     if (_data != nullptr)         return string_type(_data);     else         return string_type(); }

c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::lookup_collatename(const wchar_t* p1, const wchar_t* p2) {#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)/               && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)/               && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)   std::string name(p1, p2);#else   std::string name;   const wchar_t* p0 = p1;   while(p0 != p2)      name.append(1, char(*p0++));#endif   name = ::boost::re_detail::lookup_default_collate_name(name);#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)/               && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)/               && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)   if(name.size())      return string_type(name.begin(), name.end());#else   if(name.size())   {      string_type result;      typedef std::string::const_iterator iter;      iter b = name.begin();      iter e = name.end();      while(b != e)         result.append(1, wchar_t(*b++));      return result;   }#endif   if(p2 - p1 == 1)      return string_type(1, *p1);   return string_type();}

  /** /brief Check if a string position contains a binary operator.      /param a_Tok  [out] Operator token if one is found. This can either be a binary operator or an infix operator token.      /return true if an operator token has been found.  */  bool ParserTokenReader::IsOprt(token_type &a_Tok)  {    const char_type *const szExpr = m_strFormula.c_str();    string_type strTok;    int iEnd = ExtractOperatorToken(strTok, m_iPos);    if (iEnd==m_iPos)      return false;    // Check if the operator is a built in operator, if so ignore it here    const char_type **const pOprtDef = m_pParser->GetOprtDef();    for (int i=0; m_pParser->HasBuiltInOprt() && pOprtDef[i]; ++i)    {      if (string_type(pOprtDef[i])==strTok)        return false;    }    // Note:    // All tokens in oprt_bin_maptype are have been sorted by their length    // Long operators must come first! Otherwise short names (like: "add") that    // are part of long token names (like: "add123") will be found instead     // of the long ones.    // Length sorting is done with ascending length so we use a reverse iterator here.    funmap_type::const_reverse_iterator it = m_pOprtDef->rbegin();    for ( ; it!=m_pOprtDef->rend(); ++it)    {      const string_type &sID = it->first;      if ( sID == string_type(szExpr + m_iPos, szExpr + m_iPos + sID.length()) )      {        a_Tok.Set(it->second, strTok);        // operator was found        if (m_iSynFlags & noOPT)         {          // An operator was found but is not expected to occur at          // this position of the formula, maybe it is an infix           // operator, not a binary operator. Both operator types          // can share characters in their identifiers.          if ( IsInfixOpTok(a_Tok) )             return true;          else          {            // nope, no infix operator            return false;            //Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString());           }        }        m_iPos += (int)sID.length();        m_iSynFlags  = noBC | noOPT | noARG_SEP | noPOSTOP | noEND | noBC | noASSIGN;        return true;      }    }    return false;  }

icu_regex_traits_implementation::string_type icu_regex_traits_implementation::do_transform(const char_type* p1, const char_type* p2, const U_NAMESPACE_QUALIFIER Collator* pcoll) const{   // TODO make thread safe!!!! :   typedef u32_to_u16_iterator<const char_type*, ::UChar> itt;   itt i(p1), j(p2);#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS   std::vector< ::UChar> t(i, j);#else   std::vector< ::UChar> t;   while(i != j)      t.push_back(*i++);#endif   ::uint8_t result[100];   ::int32_t len;   if(t.size())      len = pcoll->getSortKey(&*t.begin(), static_cast< ::int32_t>(t.size()), result, sizeof(result));   else      len = pcoll->getSortKey(static_cast<UChar const*>(0), static_cast< ::int32_t>(0), result, sizeof(result));   if(std::size_t(len) > sizeof(result))   {      scoped_array< ::uint8_t> presult(new ::uint8_t[len+1]);      if(t.size())         len = pcoll->getSortKey(&*t.begin(), static_cast< ::int32_t>(t.size()), presult.get(), len+1);      else         len = pcoll->getSortKey(static_cast<UChar const*>(0), static_cast< ::int32_t>(0), presult.get(), len+1);      if((0 == presult[len-1]) && (len > 1))         --len;#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS      return string_type(presult.get(), presult.get()+len);#else      string_type sresult;      ::uint8_t const* ia = presult.get();      ::uint8_t const* ib = presult.get()+len;      while(ia != ib)         sresult.push_back(*ia++);      return sresult;#endif   }   if((0 == result[len-1]) && (len > 1))      --len;#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS   return string_type(result, result+len);#else   string_type sresult;   ::uint8_t const* ia = result;   ::uint8_t const* ib = result+len;   while(ia != ib)      sresult.push_back(*ia++);   return sresult;#endif}

			static std::pair<string_type,string_type> tokenizePair(string_type input, string_type br)			{				std::deque<string_type> tokens = tokenize<string_type>(input,br);				if ( tokens.size() == 0 )					return std::pair<string_type,string_type>(						string_type(),						string_type());				else if ( tokens.size() == 1 )					return std::pair<string_type,string_type>(						string_type(tokens[0]),						string_type());				else if ( tokens.size() == 2 )					return std::pair<string_type,string_type>(						string_type(tokens[0]),						string_type(tokens[1]));				else				{					string_type val;					for ( uint64_t i = 1; i < tokens.size(); ++i )					{						val += tokens[i];						if ( i+1 < tokens.size() )							val += br;					}					return std::pair<string_type,string_type>(						string_type(tokens[0]),						string_type(val));				}			}

void default_filter_factory< CharT >::on_string_argument(    string_type const& name, const char_type* b, const char_type* e, filter_type& filter){    filter = log::filters::attr<        string_type    >(name, std::nothrow).satisfies(log::aux::bind2nd(RelationT(), string_type(b, e)));}

//------------------------------------------------------------------------------string_type ParserErrorMsg::GetErrorMsg(EErrorCodes eError) const{    if (!m_pInstance.get())        return string_type();    else        return m_pInstance->GetErrorMsg(eError);}

void uri_builder::set_host(string_type host) {  host_.reset(string_type());  auto end = network::uri::encode_host(std::begin(host), std::end(host),                                       std::back_inserter(*host_));  std::transform(std::begin(*host_), std::end(*host_), std::begin(*host_),                 [](string_type::value_type c) { return std::tolower(c); });}

boolnsTSubstring_CharT::Assign( const substring_tuple_type& tuple, const fallible_t& )  {    if (tuple.IsDependentOn(mData, mData + mLength))      {        // take advantage of sharing here...        return Assign(string_type(tuple), fallible_t());      }    size_type length = tuple.Length();    // don't use ReplacePrep here because it changes the length    char_type* oldData;    uint32_t oldFlags;    if (!MutatePrep(length, &oldData, &oldFlags))      return false;    if (oldData)      ::ReleaseData(oldData, oldFlags);    tuple.WriteTo(mData, length);    mData[length] = 0;    mLength = length;    return true;  }

    /**     * Look up a prefix and get the currently-mapped Namespace URI.     *     * <p>This method looks up the prefix in the current context.     * Use the empty string ("") for the default Namespace.</p>     *     * @param prefix The prefix to look up.     * @return The associated Namespace URI, or empty string if the prefix     *         is undeclared in this context.     * @see #getPrefix     * @see #getPrefixes     */    string_type getURI(const string_type& prefix) const    {        for(typename contextListT::const_reverse_iterator i = contexts_.rbegin(); i != contexts_.rend(); ++i)        {            typename stringMapT::const_iterator u = i->find(prefix);            if(u != i->end())                return u->second;        } // for ...        return string_type();    } // getURI

    /**     * Return one of the prefixes mapped to a Namespace URI.     *     * <p>If more than one prefix is currently mapped to the same     * URI, this method will make an arbitrary selection; if you     * want all of the prefixes, use the {@link #getPrefixes}     * method instead.</p>     *     * <p><strong>Note:</strong> this will never return the empty (default) prefix;     * to check for a default prefix, use the {@link #getURI getURI}     * method with an argument of "".</p>     *     * @param uri The Namespace URI.     * @return One of the prefixes currently mapped to the URI supplied,     *         or an empty string if none is mapped or if the URI is assigned to     *         the default Namespace.     * @see #getPrefixes(const string_type&)     * @see #getURI     */    string_type getPrefix(const string_type& uri) const    {        for(typename contextListT::const_reverse_iterator i = contexts_.rbegin(); i != contexts_.rend(); ++i)        {            for(typename stringMapT::const_iterator u = i->begin(); u != i->end(); ++u)                if(u->second == uri)                    return u->first;        } // for ...        return string_type();    } // getPrefix

printable_string* make_printable_string(unsigned char* val) {    printable_string* result = ALLOCATE(sizeof(printable_string));    size_t len = strlen(val) + 1;    unsigned char* copy = ALLOCATE(sizeof(unsigned char*) * len);    printable* presult = (printable*)result;    strncpy(copy, val, len - 1);    copy[len - 1] = '/0';    presult->type = string_type();    presult->val = copy;    presult->size = len;    define_method(presult->type, to_string, to_string_string);    return result;}

void encode(const double latitude, const double longitude, unsigned long precision, string_type & output){    // DecodedBBox for the lat/lon + errors    DecodedBBox bbox;    bbox.maxlat = 90;    bbox.maxlon = 180;    bbox.minlat = -90;    bbox.minlon = -180;    double mid        = 0;    bool   islon      = true;    int    num_bits   = 0;    int    hash_index = 0;    // Pre-Allocate the hash string    output = string_type(precision, ' ');    unsigned int output_length = 0;    while(output_length < precision) {        if (islon) {            mid = (bbox.maxlon + bbox.minlon) / 2;            if(longitude > mid) {                hash_index = (hash_index << 1) + 1;                bbox.minlon=mid;            } else {                hash_index = (hash_index << 1) + 0;                bbox.maxlon=mid;            }        } else {            mid = (bbox.maxlat + bbox.minlat) / 2;            if(latitude > mid ) {                hash_index = (hash_index << 1) + 1;                bbox.minlat = mid;            } else {                hash_index = (hash_index << 1) + 0;                bbox.maxlat = mid;            }        }        islon = !islon;        ++num_bits;        if (5 == num_bits) {            // Append the character to the pre-allocated string            // This gives us roughly a 2x speed boost            output[output_length] = base32_codes[hash_index];            output_length++;            num_bits   = 0;            hash_index = 0;        }    }};

 std::vector<string_type> to_vector() const {     if (_data == nullptr)         return std::vector<string_type>();     std::vector<string_type> data;     auto str = string_type(_data);     struct splitter     {         bool operator()(wchar_t w) const {return w == api::env_seperator<wchar_t>();}         bool operator()(char c)    const {return c == api::env_seperator<char>   ();}     } s;     boost::split(data, _data, s);     return std::move(data); }

collate_byname<char>::string_typecollate_byname<char>::do_transform(const char* low, const char* high) const {  if (low == high)    return string_type();  size_t n = _Locale_strxfrm(_M_collate, NULL, 0, low, high - low);  // NOT PORTABLE.  What we're doing relies on internal details of the  // string implementation.  (Contiguity of string elements and presence  // of trailing zero.)  string_type buf(n, 0);  _Locale_strxfrm(_M_collate, &(*buf.begin()), n + 1, low, high - low);  return buf;}

collate_byname<char>::string_typecollate_byname<char>::do_transform(const char* low, const char* high) const {  size_t n = _Locale_strxfrm(_M_collate,                             NULL, 0,                             low, high - low);  __vector__<char, allocator<char> > buf(n);  _Locale_strxfrm(_M_collate, &buf.front(), n,                              low, high - low);   char& __c1 = *(buf.begin());   char& __c2 = (n == (size_t)-1) ? *(buf.begin() + (high-low-1)) : *(buf.begin() + n);   //   char& __c2 = *(buf.begin() + n);   return string_type( &__c1, &__c2 );}

  /** /brief Extract all characters that belong to a certain charset.    /param a_szCharSet [in] Const char array of the characters allowed in the token.     /param a_strTok [out]  The string that consists entirely of characters listed in a_szCharSet.    /param a_iPos [in] Position in the string from where to start reading.    /return The Position of the first character not listed in a_szCharSet.    /throw nothrow  */  int ParserTokenReader::ExtractToken(const char_type *a_szCharSet,                                       string_type &a_sTok,                                       int a_iPos) const  {    int iEnd = (int)m_strFormula.find_first_not_of(a_szCharSet, a_iPos);    if (iEnd==(int)string_type::npos)        iEnd = (int)m_strFormula.length();        // Assign token string if there was something found    if (a_iPos!=iEnd)      a_sTok = string_type( m_strFormula.begin()+a_iPos, m_strFormula.begin()+iEnd);    return iEnd;  }

voidnsTSubstring_CharT::AssignASCII( const char* data, size_type length )  {    // A Unicode string can't depend on an ASCII string buffer,    // so this dependence check only applies to CStrings.#ifdef CharT_is_char    if (IsDependentOn(data, data + length))      {        // take advantage of sharing here...        Assign(string_type(data, length));        return;      }#endif    if (ReplacePrep(0, mLength, length))      char_traits::copyASCII(mData, data, length);  }

	path& path::append(const path& p)	{		if (p.empty()) return *this;		if (empty()) {			return (*this = p); 		}		invalidate();		// check for something stupid like xx.append(xx);		if (&p == this) {			return append_common(string_type(p._path));		}		return append_common(p._path);	}

BOOST_LOG_API void basic_record_ostream< CharT >::init_stream(){    base_type::imbue(std::locale());    if (m_record)    {        typedef attributes::attribute_value_impl< string_type > message_impl_type;        intrusive_ptr< message_impl_type > p = new message_impl_type(string_type());        attribute_value value(p);        // This may fail if the record already has Message attribute        std::pair< attribute_value_set::const_iterator, bool > res =            m_record->attribute_values().insert(expressions::tag::message::get_name(), value);        if (!res.second)            const_cast< attribute_value& >(res.first->second).swap(value);        base_type::attach(const_cast< string_type& >(p->get()));    }}

/** /brief Check whether the token at a given position is a value token.  Value tokens are either values or constants.  /param a_Tok [out] If a value token is found it will be placed here.  /return true if a value token has been found.  */bool TokenReader::IsValTok(ptr_tok_type &a_Tok){    if (m_vValueReader.size() == 0)        return false;    stringstream_type stream(m_sExpr.c_str() + m_nPos);    string_type sTok;    try    {        // call the value recognition functions provided by the user        // Call user defined value recognition functions        int iSize = (int)m_vValueReader.size();        Value val;        for (int i = 0; i < iSize; ++i)        {            int iStart = m_nPos;            if (m_vValueReader[i]->IsValue(m_sExpr.c_str(), m_nPos, val))            {                sTok.assign(m_sExpr.c_str(), iStart, m_nPos);                if (m_nSynFlags & noVAL)                    throw ecUNEXPECTED_VAL;                m_nSynFlags = noVAL | noVAR | noFUN | noBO | noIFX | noIO;                a_Tok = ptr_tok_type(val.Clone());                a_Tok->SetIdent(string_type(sTok.begin(), sTok.begin() + (m_nPos - iStart)));                return true;            }        }    }    catch (EErrorCodes e)    {        ErrorContext err;        err.Errc = e;        err.Pos = m_nPos;        err.Ident = sTok;        err.Expr = m_sExpr;        err.Pos = m_nPos - (int)sTok.length();        throw ParserError(err);    }    return false;}

 int module_loader_op::write(shared_ptr<fs_entry> file_ent, char const *buf, size_t size, off_t offset) {     int ret = size;     auto request = string_type(buf, size);     request_parser parser;     if (parser.parse(request)) try {         typedef core_file_system::priority priority;         if (parser.get_command() == "load")             for (auto&& mod_name : parser.get_args())                 fs_root_->install_module(priority::normal, mod_name[0], paths_);         else if (parser.get_command() == "unload")             for (auto&& mod_name : parser.get_args())                 fs_root_->uninstall_module(mod_name[0]);     } catch (no_such_ops_type& e) {             BOOST_LOG_TRIVIAL(error) << "module_loader: " << e.what();             throw_system_error(EINVAL);     } else         ret = -ENOTSUP;     return ret; }

hdf5_oprimitive::write_hdf5_dataset(    const std::string *t,    std::size_t data_count,    std::size_t object_number){    BOOST_ASSERT(data_count == 1);    char const* c_string = t->c_str();    hdf5_datatype string_type(H5T_STRING);    if(use_variable_length_strings_ || t->empty()) {        string_type.resize(H5T_VARIABLE);        write_dataset_basic(&c_string, data_count, string_type, object_number);    }    else {        string_type.resize(t->size());        write_dataset_basic(c_string, data_count, string_type, object_number);    }    string_type.close();}

boolnsTSubstring_CharT::Assign( const char_type* data, size_type length, const fallible_t& )  {    if (!data)      {        Truncate();        return true;      }    if (length == size_type(-1))      length = char_traits::length(data);    if (IsDependentOn(data, data + length))      {        return Assign(string_type(data, length), fallible_t());      }    if (!ReplacePrep(0, mLength, length))      return false;    char_traits::copy(mData, data, length);    return true;  }

voidnsTSubstring_CharT::Assign( const char_type* data, size_type length )  {      // unfortunately, some callers pass null :-(    if (!data)      {        Truncate();        return;      }    if (length == size_type(-1))      length = char_traits::length(data);    if (IsDependentOn(data, data + length))      {        // take advantage of sharing here...        Assign(string_type(data, length));        return;      }    if (ReplacePrep(0, mLength, length))      char_traits::copy(mData, data, length);  }