C++ string_ref::to_string方法代码示例

	AttributeSelector::AttributeSelector(SelectorOperator op, boost::string_ref key, boost::string_ref value) :
		m_operator(op),
		m_attributeNameString(key.to_string()),
		m_attributeNameRef(m_attributeNameString),
		m_attributeValueString(value.to_string()),
		m_attributeValueRef(m_attributeValueString)
	{
		if (m_attributeNameRef.size() == 0)
		{
			throw std::runtime_error(u8"In AttributeSelector::AttributeSelector(SelectorOperator, boost::string_ref, const bool) - Supplied attribute identifier has zero length.");
		}

		if (m_attributeValueRef.size() == 0)
		{
			throw std::runtime_error(u8"In AttributeSelector::AttributeSelector(SelectorOperator, boost::string_ref, const bool) - Supplied attribute value has zero length.");
		}

		if (m_operator == SelectorOperator::ValueContainsElementInWhitespaceSeparatedList)
		{
			if (m_attributeNameRef.find_first_of(u8"\t\r\n ") != std::string::npos)
			{
				throw std::runtime_error(u8"In AttributeSelector::AttributeSelector(SelectorOperator, boost::string_ref, const bool) - Constructed ValueContainsElementInWhitespaceSeparatedList attribute selector, but spaces exist in the search value. This is not allowed.");
			}
		}

		#ifndef NDEBUG
			#ifdef GQ_VERBOSE_DEBUG_NFO
				std::cout << "Built AttributeSelector with operator " << static_cast<size_t>(m_operator) << " with key " << m_attributeNameRef << " looking for value " << m_attributeValueRef << std::endl;
			#endif
		#endif

		switch (m_operator)
		{
			case SelectorOperator::ValueEquals:
			case SelectorOperator::ValueContainsElementInWhitespaceSeparatedList:
			{
				AddMatchTrait(m_attributeNameRef, m_attributeValueRef);
			}
			break;

			case SelectorOperator::Exists:
			case SelectorOperator::ValueContains:
			case SelectorOperator::ValueHasPrefix:
			case SelectorOperator::ValueHasSuffix:
			case SelectorOperator::ValueIsHyphenSeparatedListStartingWith:
			{
				AddMatchTrait(m_attributeNameRef, SpecialTraits::GetAnyValue());
			}
			break;
		}
	}

std::string get_directory_listing( boost::string_ref folder ) {
	namespace fs = boost::filesystem;
	fs::path p { folder.to_string( ) };
	std::ostringstream ss;
	try {
		if( exists( p ) ) {
			if( fs::is_regular_file( p ) ) {
				ss << p << " size is " << fs::file_size( p ) << "\r\n";
			} else if( fs::is_directory( p ) ) {
				ss << p << " is a directory containing:\n";
				std::copy( fs::directory_iterator( p ), fs::directory_iterator( ), std::ostream_iterator<fs::directory_entry>( ss, "\r\n" ) );
			} else {
				ss << p << " exists, but is neither a regular file nor a directory\n";
			}
		} else {
			ss << p << " does not exist\n";
		}
	}

	catch( const fs::filesystem_error& ex ) {
		ss << "ERROR: " << ex.what( ) << '\n';
	}

	return ss.str( );
}

				base::OptionalError read_file( boost::string_ref path, base::data_t & buffer, bool append_buffer ) {
					std::ifstream in_file( path.to_string( ), std::ifstream::ate | std::ifstream::binary );
					if( !in_file ) {
						auto result = base::create_optional_error( "Could not open file" );
						result->add( "where", "read_file#open" );
						return result;
					}

					auto fsize = in_file.tellg( );
					if( fsize < 0 ) {
						auto result = base::create_optional_error( "Error reading file length" );
						result->add( "where", "read_file#tellg" );
						return result;
					}
					if( !in_file.seekg( 0 ) ) {
						auto result = base::create_optional_error( "Error reseting file position to beginning" );
						result->add( "where", "read_file#seekg" );
						return result;
					}

					size_t first_pos = append_buffer ? buffer.size( ) : 0;
					buffer.resize( first_pos + static_cast<size_t>(fsize) );

					if( !in_file.read( buffer.data( ) + first_pos, fsize ) ) {
						auto result = base::create_optional_error( "Error reading file" );
						result->add( "where", "read_file#read" );
						return result;
					}
					return base::create_optional_error( );
				}

void
history::add (const boost::string_ref& text)
{
	this->lines[this->realpos] = text.to_string();
	this->realpos++;
	if (this->realpos == HISTORY_SIZE)
		this->realpos = 0;
	this->pos = this->realpos;
}

std::string CExpressionConverter::ToSuffixNotation(boost::string_ref expression)
{
	auto str = expression.to_string();
	str.erase(remove_if(str.begin(), str.end(), isspace), str.end());
	m_expression = str;
	string output;
	HandlePlusAndMinus(output);
	if (!output.empty())
	{
		output.erase(--output.end());
	}
	return output;
}

				base::OptionalError write_file( boost::string_ref path, base::data_t const & buffer, FileWriteMode mode, size_t bytes_to_write ) {
					// TODO: Write to a temp file first and then move
					if( 0 == bytes_to_write || bytes_to_write > buffer.size( ) ) {
						bytes_to_write = buffer.size( );	// TODO: verify this is what we want.  Covers errors but that may be OK
					}
					std::ofstream out_file;
					switch( mode ) {
					case FileWriteMode::AppendOrCreate:
						out_file.open( path.to_string( ), std::ostream::binary | std::ostream::out | std::ostream::app );
						break;
					case FileWriteMode::MustBeNew: {
						if( std::ifstream( path.to_string( ) ) ) {
							// File exists.  Error
							auto error = base::create_optional_error( "Attempt to open an existing file when MustBeNew requested" );
							error->add( "where", "write_file" );
							return error;
						}
						out_file.open( path.to_string( ), std::ostream::binary | std::ostream::out );
						break;
					}
					case FileWriteMode::OverwriteOrCreate:
						out_file.open( path.to_string( ), std::ostream::binary | std::ostream::out | std::ostream::trunc );
						break;
					default:
						throw std::runtime_error( "Unknown FileWriteMode specified" );
					}
					if( !out_file ) {
						auto error = base::create_optional_error( "Could not open file for writing" );
						error->add( "where", "write_file#open" );
						return error;
					}
					if( !out_file.write( buffer.data( ), static_cast<std::streamoff>(bytes_to_write) ) ) {
						auto error = base::create_optional_error( "Error writing data to file" );
						error->add( "where", "write_file#write" );
						return error;
					}
					return base::create_optional_error( );
				}

/* Handle message tags.
 *
 * See http://ircv3.atheme.org/specification/message-tags-3.2 
 */
static void
handle_message_tags (const server &serv, const boost::string_ref & tags_str,
							message_tags_data &tags_data)
{
	/* FIXME We might want to avoid the allocation overhead here since 
	 * this might be called for every message from the server.
	 */
	std::istringstream inbuf{ tags_str.to_string() };
	for (std::string tag; std::getline(inbuf, tag, ';');)
	{
		auto value_loc = tag.find_first_of('=');
		if (value_loc == std::string::npos)
			continue;

		auto key = tag.substr(0, value_loc - 1);
		auto value = tag.substr(value_loc + 1);

		if (serv.have_server_time && key == "time")
			handle_message_tag_time (value, tags_data);
	}
}

		/**
		 * コンストラクタ
		 * @param name ファイル名
		 * @param msg  エラーメッセージ
		 */
		explicit FileException(boost::string_ref name, boost::string_ref msg)
			: Exception(name.to_string() + '\n' + msg.to_string(), nullptr) {}

				std::streampos file_size( boost::string_ref path ) {
					std::ifstream in_file( path.to_string( ), std::ifstream::ate | std::ifstream::binary );
					return file_size( in_file );
				}

/* irc_inline() - 1 single line received from serv */
void
server::p_inline (const boost::string_ref& text)
{
	session *sess;
	char *type;
	char *word[PDIWORDS+1];
	char *word_eol[PDIWORDS+1];
	message_tags_data tags_data = message_tags_data();

	std::string pdibuf(text.size(), '\0');

	sess = this->front_session;

	/* Python relies on this */
	word[PDIWORDS] = NULL;
	word_eol[PDIWORDS] = NULL;
	std::string buf;
	if (text.starts_with('@'))
	{
		auto sep = text.find_first_of(' ');
		if (sep == boost::string_ref::npos)
			return;
		
		/* skip the '@' */
		auto tags = text.substr(1, sep - 1);
		
		buf = text.substr(sep + 1).to_string();

		handle_message_tags(*this, tags, tags_data);
	}
	else
	{
		buf = text.to_string();
	}

	url_check_line(buf.data(), buf.size());

	/* split line into words and words_to_end_of_line */
	process_data_init (&pdibuf[0], &buf[0], word, word_eol, false, false);

	if (buf[0] == ':')
	{
		/* find a context for this message */
		if (this->is_channel_name (word[3]))
		{
			auto tmp = find_channel (word[3]);
			if (tmp)
				sess = &(*tmp);
		}

		/* for server messages, the 2nd word is the "message type" */
		type = word[2];

		word[0] = type;
		word_eol[1] = &buf[0];	/* keep the ":" for plugins */

		if (plugin_emit_server(sess, type, word, word_eol,
			tags_data.timestamp))
		{
			return;
		}

		word[1]++;
		word_eol[1] = &buf[1];	/* but not for HexChat internally */

	} else
	{
		word[0] = type = word[1];

		if (plugin_emit_server(sess, type, word, word_eol,
			tags_data.timestamp))
		{
			return;
		}
	}

	if (buf[0] != ':')
	{
		process_named_servermsg (sess, &buf[0], word[0], word_eol, &tags_data);
		return;
	}

	/* see if the second word is a numeric */
	std::locale locale;
	if (std::isdigit (word[2][0], locale))
	{
		char* t = word_eol[4];
		if (*t == ':')
			t++;

		process_numeric (sess, atoi (word[2]), word, word_eol, t, &tags_data);
	} else
	{
		process_named_msg (sess, type, word, word_eol, &tags_data);
	}
}

std::string CHttpUrl::ParseDocument(boost::string_ref & url)
{
	return url.to_string();
}