C++ string_type::data方法代码示例

 testbuf(const string_type& str)
     : str_(str)
 {
     base::setg(const_cast<CharT*>(str_.data()),
                const_cast<CharT*>(str_.data()),
                const_cast<CharT*>(str_.data()) + str_.size());
 }

	void backend::consume(string_type const& formatted_message)
	{
		if (!impl_)
			return;

		if((impl_->file_.is_open() && (impl_->written_ + formatted_message.size() >= 512*1024) )
			|| !impl_->file_.good()
			)
		{
			rotate_file();
		}

		if (!impl_->file_.is_open())
		{
			fs::create_directories(impl_->root_);
			impl_->file_.open((impl_->root_ / (impl_->name_ + L".log")).c_str(), std::ios_base::app | std::ios_base::out);
			if (!impl_->file_.is_open())
			{
				throw bee::exception("Failed to open file '%s' for writing.", (impl_->root_ / (impl_->name_ + L".log")).string().c_str());
			}

			impl_->written_ = static_cast<std::streamoff>(impl_->file_.tellp());
		}

		impl_->file_.write(formatted_message.data(), static_cast<std::streamsize>(formatted_message.size()));
		impl_->file_.put(static_cast<string_type::value_type>('\n'));
		impl_->written_ += formatted_message.size() + 1;
		impl_->file_.flush();
	}

//! The method writes the message to the sink
BOOST_LOG_API void text_multifile_backend::consume(record_view const& rec, string_type const& formatted_message)
{
    if (!m_pImpl->m_FileNameComposer.empty())
    {
        filesystem::path file_name = m_pImpl->make_absolute(m_pImpl->m_FileNameComposer(rec));
        filesystem::create_directories(file_name.parent_path());
        m_pImpl->m_File.open(file_name, std::ios_base::out | std::ios_base::app);
        if (m_pImpl->m_File.is_open())
        {
            m_pImpl->m_File.write(formatted_message.data(), static_cast< std::streamsize >(formatted_message.size()));
            m_pImpl->m_File.put(static_cast< string_type::value_type >('\n'));
            m_pImpl->m_File.close();
        }
    }
}

BOOST_LOG_API void basic_text_ostream_backend< CharT >::consume(record_view const&, string_type const& message)
{
    typename string_type::const_pointer const p = message.data();
    typename string_type::size_type const s = message.size();
    typename implementation::ostream_sequence::const_iterator
        it = m_pImpl->m_Streams.begin(), end = m_pImpl->m_Streams.end();
    for (; it != end; ++it)
    {
        register stream_type* const strm = it->get();
        if (strm->good())
        {
            strm->write(p, static_cast< std::streamsize >(s));
            strm->put(static_cast< char_type >('\n'));

            if (m_pImpl->m_fAutoFlush)
                strm->flush();
        }
    }
}

 ///
 /// Create a binary string from string \a s, that can be compared to other, useful for collation of multiple
 /// strings.
 ///
 /// The transformation follows these rules:
 /// \code
 ///   compare(level,s1,s2) == sign( transform(level,s1).compare(transform(level,s2)) );
 /// \endcode
 ///
 string_type transform(level_type level,string_type const &s) const
 {
     return do_transform(level,s.data(),s.data()+s.size());
 }

 long hash(level_type level,string_type const &s) const
 {
     return do_hash(level,s.data(),s.data()+s.size());
 }

 ///
 /// Compare two strings \a l and \a r using collation level \a level
 ///
 /// Returns -1 if the first of the two strings sorts before the seconds, returns 1 if sorts after and 0 if
 /// they considered equal.
 ///
 ///
 int compare(level_type level,string_type const &l,string_type const &r) const
 {
     return do_compare(level,l.data(),l.data()+l.size(),r.data(),r.data()+r.size());
 }

 /*!
  * The method finds the attribute value by name.
  *
  * \param key Attribute name.
  * \return Iterator to the found element or \c end() if the attribute with such name is not found.
  */
 const_iterator find(string_type const& key) const
 {
     return find_impl(key.data(), key.size());
 }