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

	explicit glob_matcher(const boost::string_ref pat)
	noexcept : m_pat{pat}
	{
		// If we are in debug mode, ensure that the pattern is valid.
		assert(m_pat.length() > 0);

		#ifndef NDEBUG
		auto i = 0u;

		/*
		** The following sequences are considered to be syntax
		** violations when they occur within glob patterns:
		**
		**   1. Special characters within groups.
		**   2. Empty groups.
		**   3. Any backslash not followed by a special character; this
		**   includes trailing backslashes.
		*/
		do switch (m_pat[i]) {
		default:
		case '*':
		case '?':     ++i;                            continue;
		case '[':     assert(pat[++i] != ']');        goto group_mode;
		// Ensure that the character escaped using a backslash is a
		// special character.
		case '\\':    assert(is_glob(pat[++i])); ++i; continue;
		regular_mode:                                 continue;
		} while (i != pat.length());
		return;
		
		// Check to ensure that the current group is valid.
	group_mode:
		for(;;) switch (m_pat[i]) {
		default:   ++i;                            continue;
		case ']':  ++i;                            goto regular_mode;
		case '\\': assert(is_glob(pat[++i])); ++i; continue;
		case '*':
		case '?':
		case '\0': assert(false && "Invalid group.");
		}

		#endif
	}

	/*
	** Determines whether the directory entry's name matches the glob
	** pattern.
	*/
	bool operator()(const directory_entry& ent)
	const noexcept
	{
		#ifndef NDEBUG
			assert(m_pat.length() > 0);
		#endif

		// Offset into pattern that we are matching.
		auto i = 0u;
		// Offset into the file name.
		auto j = 0u;
		auto s = ent.name();

		do switch(m_pat[i]) {
		default:   if (m_pat[i++] != s[j++])         return false; continue;
		case '*':  ++i; return match_wildcard(s, i, j);
		case '?':  ++i; ++j;                                       continue;
		case '[':  ++i; if (!match_group(s, i, j))   return false; continue;
		case '\\': ++i; if (m_pat[i++] != s[j++])    return false; continue;
		} while (i != m_pat.length() && j != s.length());
		return (i == m_pat.length() || m_pat[i] == '*') && j == s.length();
	}

	explicit directory_iterator(const boost::string_ref dir)
	: m_dir_len(dir.length())
	{
		// Ensure that the string resulting from concatenating the path
		// to the directory, the platform directory separator, and the
		// file name can fit in the path buffer. The trailing "+ 1" term
		// accounts for the null terminating character.
		assert(m_dir_len + 1 + PLATFORM_MAX_FILENAME_LENGTH + 1 <=
			PLATFORM_MAX_PATHNAME_LENGTH);

		// We need to copy `dir` to `m_path_buf`, because `dir` might
		// not be null-terminated.
		boost::copy(dir, m_path_buf.begin());
		m_path_buf[dir.length()] = '\0';
		m_fd = ::open(m_path_buf.begin(), O_RDONLY);

		if (m_fd < 0) {
			throw std::system_error{errno, std::system_category(),
				"failed to open directory"};
		}

		struct stat st;
		if (::fstat(m_fd, &st) == -1) {
			throw std::system_error{errno, std::system_category(),
				"failed to get directory status"};
		}

		m_bufsz = detail::rumpot(st.st_size, st.st_blksize);
		m_buf = std::unique_ptr<char[]>{new char[m_bufsz]};

		// We do not want to copy the null character, so we only copy
		// until dir + dir_len rather than dir + dir_len + 1.
		boost::copy(dir, m_path_buf.data());
		m_path_buf[m_dir_len] = PLATFORM_DIRECTORY_SEPARATOR;
		read_chunk();
	}

int list_modules(
	const boost::string_ref prog,
	const boost::string_ref desc
)
{
	if (desc.length() > 0) {
		println("Suite ${quote}: $.", get_suite(prog), desc);
	}
	else {
		println("Suite ${quote}.", get_suite(prog));
	}

	for (const auto& m : module_list{}) {
		if (m.description().length() > 0) {
			println("Module ${quote}: $.", m.name(), m.description());
		}
		else {
			println("Module ${quote}.", m.name(), m.description());
		}
	}
	return EXIT_SUCCESS;
}

	/*
	** Updates the current file at the end of the directory path string.
	*/
	void update_path(const boost::string_ref filename)
	const noexcept
	{
		boost::copy(filename, m_path_buf.data() + m_dir_len + 1);
		m_path_len = m_dir_len + filename.length();
	}

	/*
	** After this method is called, we must iteratively test each character
	** of `s` beginning at `s[j]` to check whether it matches the characters
	** after the wildcards beginning at `m_pat[i - 1]`.
	*/
	bool match_wildcard(const boost::string_ref s, unsigned i, unsigned j)
	const noexcept
	{
		/*
		** We keep track of the index `pi` after each wildcard that we
		** are trying to match, and the index `pj` into `s` at which we
		** are looking for a match. If the characters after the wildcard
		** fail to match the string beginning at `s[j]`, then we reset
		** `i` to `pi` and `j` to `pj`.
		*/

		// First index of current subpattern for which we are looking
		// for a match. A subpattern is a pattern between a wildcard and
		// another wildcard or null character.
		auto pi = i;
		// Current index at which we are looking for a match.
		auto pj = j;

		while (s[j] != '\0') switch (m_pat[i]) {
			default:
				if (m_pat[i] != s[j]) {
					++pj;
					i = pi;
					j = pj;
					continue;
				}
				else {
					++i;
					++j;
					continue;
				}
			case '*':
				++i;
				pi = i;
				pj = j;
				continue;
			case '?':
				++i;
				++j;
				continue;
			case '[':
				++i;
				if (!match_group(s, i, j)) {
					++pj;
					i = pi;
					j = pj;
				}
				continue;
			case '\\':
				/*
				** If we increment `i` by one, then we will
				** interpret the following escaped character as
				** a special character at the next iteration. To
				** prevent this, we must anticipate what should
				** happen in the next iteration.
				*/
				if (m_pat[i + 1] != s[j]) {
					++pj;
					i = pi;
					j = pj;
					continue;
				}
				else {
					i += 2;
					++j;
					continue;
				}
		}
		return i == m_pat.length();
	}

 format_intrusive_result format_value(boost::string_ref value)
 {
     return format_intrusive_result(value.data(), value.length());
 }