void test_strview_basics(const string_view& sv, const char *p, size_t n) {
ASSERT_EQ(p, sv.data());
ASSERT_EQ(n, sv.size());
ASSERT_EQ(n, sv.length());
ASSERT_EQ((n == 0), sv.empty());
ASSERT_EQ(p, sv.cbegin());
ASSERT_EQ(p, sv.begin());
ASSERT_EQ(p + n, sv.cend());
ASSERT_EQ(p + n, sv.end());
using reviter_t = std::reverse_iterator<string_view::const_iterator>;
ASSERT_EQ(reviter_t(sv.end()), sv.rbegin());
ASSERT_EQ(reviter_t(sv.begin()), sv.rend());
ASSERT_EQ(reviter_t(sv.cend()), sv.crbegin());
ASSERT_EQ(reviter_t(sv.cbegin()), sv.crend());
for (size_t i = 0; i < n; ++i) {
ASSERT_EQ(p[i], sv[i]);
ASSERT_EQ(p[i], sv.at(i));
}
ASSERT_THROW(sv.at(n), std::out_of_range);
ASSERT_THROW(sv.at(string_view::npos), std::out_of_range);
if (n > 0) {
ASSERT_EQ(p, &(sv.front()));
ASSERT_EQ(p + (n-1), &(sv.back()));
ASSERT_EQ(p[0], sv.front());
ASSERT_EQ(p[n-1], sv.back());
}
}
string transcription::to_rna(string_view strand)
{
string result;
transform(strand.begin(), strand.end(), back_inserter(result),
static_cast<char (*)(char)>(to_rna));
return result;
}
int main()
{
using string_view = std::experimental::string_view;
using u16string_view = std::experimental::u16string_view;
using u32string_view = std::experimental::u32string_view;
using wstring_view = std::experimental::wstring_view;
test(string_view {});
test(string_view { "123"});
test(u16string_view{});
test(u16string_view{u"123"});
test(u32string_view{});
test(u32string_view{U"123"});
test(wstring_view {});
test(wstring_view {L"123"});
{
constexpr string_view sv { "123", 3 };
constexpr u16string_view u16sv {u"123", 3 };
constexpr u32string_view u32sv {U"123", 3 };
constexpr wstring_view wsv {L"123", 3 };
static_assert ( sv.begin() != sv.end(), "" );
static_assert ( u16sv.begin() != u16sv.end(), "" );
static_assert ( u32sv.begin() != u32sv.end(), "" );
static_assert ( wsv.begin() != wsv.end(), "" );
static_assert ( sv.begin() != sv.cend(), "" );
static_assert ( u16sv.begin() != u16sv.cend(), "" );
static_assert ( u32sv.begin() != u32sv.cend(), "" );
static_assert ( wsv.begin() != wsv.cend(), "" );
}
}
void Request::add_line_to_multiline_header(const string_view& line,
const string_view& header)
{
auto non_whitespace_pos = line.find_first_not_of("\t ");
if (non_whitespace_pos != line.end())
if (!header.empty())
headers_[header.str()] += line.substr(non_whitespace_pos).str();
}
string_view ParserKeyword::getDeckName( const string_view& str ) {
auto first_sep = std::find_if( str.begin(), str.end(), RawConsts::is_separator() );
// only look at the first 8 characters (at most)
if( std::distance( str.begin(), first_sep ) < 9 )
return { str.begin(), first_sep };
return { str.begin(), str.begin() + 9 };
}
config_option::config_option(string_view category, string_view name,
string_view description, const meta_state* meta,
void* value)
: meta_(meta),
value_(value) {
using std::copy;
using std::accumulate;
auto comma = name.find(',');
auto long_name = name.substr(0, comma);
auto short_names = comma == string_view::npos ? string_view{}
: name.substr(comma + 1);
auto total_size = [](std::initializer_list<string_view> xs) {
return (xs.size() - 1) // one separator between all fields
+ accumulate(xs.begin(), xs.end(), size_t{0},
[](size_t x, string_view sv) { return x + sv.size(); });
};
auto ts = total_size({category, long_name, short_names, description});
CAF_ASSERT(ts <= std::numeric_limits<uint16_t>::max());
buf_size_ = static_cast<uint16_t>(ts);
buf_.reset(new char[ts]);
// fille the buffer with "<category>.<long-name>,<short-name>,<descriptions>"
auto first = buf_.get();
auto i = first;
auto pos = [&] {
return static_cast<uint16_t>(std::distance(first, i));
};
// <category>.
i = copy(category.begin(), category.end(), i);
category_separator_ = pos();
*i++ = '.';
// <long-name>,
i = copy(long_name.begin(), long_name.end(), i);
long_name_separator_ = pos();
*i++ = ',';
// <short-names>,
i = copy(short_names.begin(), short_names.end(), i);
short_names_separator_ = pos();
*i++ = ',';
// <description>
i = copy(description.begin(), description.end(), i);
CAF_ASSERT(pos() == buf_size_);
}
bool ParserKeyword::validDeckName( const string_view& name) {
if( !validNameStart( name ) )
return false;
const auto valid = []( char c ) {
return std::isalnum( c ) || c == '-' || c == '_' || c == '+';
};
return std::all_of( name.begin() + 1, name.end(), valid );
}
bool ParserKeyword::matches(const string_view& name ) const {
if (!validDeckName(name ))
return false;
else if( m_deckNames.count( name.string() ) )
return true;
else if (hasMatchRegex()) {
return boost::regex_match( name.begin(), name.end(), m_matchRegex);
}
return false;
}
static int ProcessBrackets(string_view const Str, wchar_t const EndMark, brackets& Brackets)
{
for (auto Iterator = Str.begin(); Iterator != Str.end(); ++Iterator)
{
if (*Iterator == L'(')
{
if (!Brackets.Bracket)
{
Brackets.Bracket = true;
Brackets.BeginBracket = &*Iterator;
}
++Brackets.BracketsCount;
}
else if (*Iterator == L')')
{
if (!Brackets.BracketsCount)
return 0;
--Brackets.BracketsCount;
if (!Brackets.BracketsCount)
{
if (!Brackets.EndBracket)
Brackets.EndBracket = &*Iterator;
}
}
else if (*Iterator == EndMark && !!Brackets.BeginBracket == !!Brackets.EndBracket)
{
if (Brackets.BracketsCount)
return 0;
return Iterator - Str.begin() + 1;
}
}
return 0;
};
int main()
{
typedef std::string_view string_view;
typedef std::u16string_view u16string_view;
typedef std::u32string_view u32string_view;
typedef std::wstring_view wstring_view;
test(string_view ());
test(u16string_view());
test(u32string_view());
test(wstring_view ());
test(string_view ( "123"));
test(wstring_view (L"123"));
#if TEST_STD_VER >= 11
test(u16string_view{u"123"});
test(u32string_view{U"123"});
#endif
#if TEST_STD_VER > 11
{
constexpr string_view sv { "123", 3 };
constexpr u16string_view u16sv {u"123", 3 };
constexpr u32string_view u32sv {U"123", 3 };
constexpr wstring_view wsv {L"123", 3 };
static_assert ( sv.begin() != sv.end(), "" );
static_assert ( u16sv.begin() != u16sv.end(), "" );
static_assert ( u32sv.begin() != u32sv.end(), "" );
static_assert ( wsv.begin() != wsv.end(), "" );
static_assert ( sv.begin() != sv.cend(), "" );
static_assert ( u16sv.begin() != u16sv.cend(), "" );
static_assert ( u32sv.begin() != u32sv.cend(), "" );
static_assert ( wsv.begin() != wsv.cend(), "" );
}
#endif
}
inline bool is_dot_dot(const string_view &s)
{ return (s.end()-s.begin()==2) && (*(s.begin())=='.') && (*(s.begin()+1)=='.'); }
static string ConvertString(const string_view Src)
{
string Result;
Result.reserve(Src.size());
for (auto i = Src.begin(); i != Src.end(); ++i)
{
switch (*i)
{
case L'\\':
if (++i == Src.end())
{
Result.push_back(L'\\');
return Result;
}
switch (*i)
{
case L'\\':
Result.push_back(L'\\');
break;
case L'"':
Result.push_back(L'"');
break;
case L'n':
Result.push_back(L'\n');
break;
case L'r':
Result.push_back(L'\r');
break;
case L'b':
Result.push_back(L'\b');
break;
case L't':
Result.push_back('\t');
break;
default:
Result.push_back(L'\\');
--i;
break;
}
break;
case L'"':
Result.push_back(L'"');
if (++i == Src.end())
return Result;
if (*i != L'"')
--i;
break;
default:
Result.push_back(*i);
break;
}
}
return Result;
}