for (char c : val) {

if (std::islower(static_cast<unsigned char>(c))) {

return false;

}

}

return true;

for (char c : val) {

if (std::isupper(static_cast<unsigned char>(c))) {

return false;

}

}

return true;

for (auto & part : parts) {

part.is_input = true;

}

if (parts.size() == 1) {

return parts[0].val;

}

std::ostringstream oss;

for (const auto & part : parts) {

oss << part.val;

}

return oss.str();

size_t len = 0;

for (const auto & part : parts) {

len += part.val.length();

}

return len;

for (const auto & part : parts) {

hash.update(part.val.data(), part.val.length());

}

for (const auto & part : parts) {

if (!part.is_input) {

return false;

}

}

return true;

for (const auto & part : parts) {

if (!part.is_uppercase()) {

return false;

}

}

return true;

for (const auto & part : parts) {

if (!part.is_lowercase()) {

return false;

}

}

return true;

if (other.all_parts_are_input()) {

for (auto & part : parts) {

part.is_input = true;

}

}

for (const auto & part : other.parts) {

parts.push_back(part);

}

return *this;

for (auto & part : self.parts) {

part.val = fn(part.val);

}

return self;

return apply_transform(*this, [](const std::string & s) {

std::string res = s;

std::transform(res.begin(), res.end(), res.begin(), ::toupper);

return res;

});

return apply_transform(*this, [](const std::string & s) {

std::string res = s;

std::transform(res.begin(), res.end(), res.begin(), ::tolower);

return res;

});

return apply_transform(*this, [](const std::string & s) {

if (s.empty()) return s;

std::string res = s;

res[0] = ::toupper(static_cast<unsigned char>(res[0]));

std::transform(res.begin() + 1, res.end(), res.begin() + 1, ::tolower);

return res;

});

return apply_transform(*this, [](const std::string & s) {

std::string res = s;

bool capitalize_next = true;

for (char &c : res) {

if (isspace(static_cast<unsigned char>(c))) {

capitalize_next = true;

} else if (capitalize_next) {

c = ::toupper(static_cast<unsigned char>(c));

capitalize_next = false;

} else {

c = ::tolower(static_cast<unsigned char>(c));

}

}

return res;

});

static auto strip_part = [](const std::string & s, bool left, bool right, std::optional<const std::string_view> chars) -> std::string {

size_t start = 0;

size_t end = s.length();

auto match_char = [&chars](unsigned char c) -> bool {

return chars ? (*chars).find(c) != std::string::npos : isspace(c);

};

if (left) {

while (start < end && match_char(static_cast<unsigned char>(s[start]))) {

++start;

}

}

if (right) {

while (end > start && match_char(static_cast<unsigned char>(s[end - 1]))) {

--end;

}

}

return s.substr(start, end - start);

};

if (parts.empty()) {

return *this;

}

if (left) {

for (size_t i = 0; i < parts.size(); ++i) {

parts[i].val = strip_part(parts[i].val, true, false, chars);

if (parts[i].val.empty()) {

// remove empty part

parts.erase(parts.begin() + i);

--i;

continue;

} else {

break;

}

}

}

if (right) {

for (size_t i = parts.size(); i-- > 0;) {

parts[i].val = strip_part(parts[i].val, false, true, chars);

if (parts[i].val.empty()) {

// remove empty part

parts.erase(parts.begin() + i);

continue;

} else {

break;

}

}

}

return *this;