Files
llama.cpp/common/jinja/string.cpp
T
HaoJun ZHANGandXuan Son Nguyen 4f2187e73d jinja : reduce template rendering overhead (#32023)
* jinja : reduce value allocation and lookup overhead

Assisted-by: GPT-6 Astra

* jinja : address rendering review feedback

Assisted-by: GPT-6 Astra

* jinja : test multipart strings and simplify lookup

Assisted-by: GPT-6 Astra

* fix "undefined hint"

* fix divisibleby 0

* clean up

---------

Co-authored-by: Xuan Son Nguyen <son@huggingface.co>
2026-11-14 13:34:20 +01:00

259 lines
6.6 KiB
C++

#include "jinja/string.h"
#include "jinja/value.h"
#include <algorithm>
#include <functional>
#include <optional>
#include <sstream>
#include <string>
#include <vector>
namespace jinja {
//
// string_part
//
bool string_part::is_uppercase() const {
for (char c : val) {
if (std::islower(static_cast<unsigned char>(c))) {
return false;
}
}
return true;
}
bool string_part::is_lowercase() const {
for (char c : val) {
if (std::isupper(static_cast<unsigned char>(c))) {
return false;
}
}
return true;
}
//
// string
//
void string::mark_input() {
for (auto & part : parts) {
part.is_input = true;
}
}
std::string string::str() const {
std::string result;
result.reserve(length());
for (const auto & part : parts) {
result += part.val;
}
return result;
}
bool string::empty() const {
for (const auto & part : parts) {
if (!part.val.empty()) {
return false;
}
}
return true;
}
std::optional<char> string::byte_at(size_t index) const {
for (const auto & part : parts) {
if (index < part.val.size()) {
return part.val[index];
}
index -= part.val.size();
}
return {};
}
bool string::equals(const string & other) const {
size_t part = 0, offset = 0;
for (const auto & left : parts) {
std::string_view text(left.val);
while (!text.empty()) {
while (part < other.parts.size() && offset == other.parts[part].val.size()) {
++part;
offset = 0;
}
if (part == other.parts.size()) {
return false;
}
const auto & right = other.parts[part].val;
const auto count = std::min(text.size(), right.size() - offset);
if (text.substr(0, count) != std::string_view(right).substr(offset, count)) {
return false;
}
text.remove_prefix(count);
offset += count;
}
}
while (part < other.parts.size() && offset == other.parts[part].val.size()) {
++part;
offset = 0;
}
return part == other.parts.size();
}
size_t string::length() const {
size_t len = 0;
for (const auto & part : parts) {
len += part.val.length();
}
return len;
}
void string::hash_update(hasher & hash) const noexcept {
for (const auto & part : parts) {
hash.update(part.val.data(), part.val.length());
}
}
bool string::all_parts_are_input() const {
for (const auto & part : parts) {
if (!part.is_input) {
return false;
}
}
return true;
}
bool string::is_uppercase() const {
for (const auto & part : parts) {
if (!part.is_uppercase()) {
return false;
}
}
return true;
}
bool string::is_lowercase() const {
for (const auto & part : parts) {
if (!part.is_lowercase()) {
return false;
}
}
return true;
}
// mark this string as input if other has ALL parts as input
void string::mark_input_based_on(const string & other) {
if (other.all_parts_are_input()) {
for (auto & part : parts) {
part.is_input = true;
}
}
}
string & string::append(const string & other) {
for (const auto & part : other.parts) {
parts.push_back(part);
}
return *this;
}
// in-place transformation
using transform_fn = std::function<std::string(const std::string&)>;
static string apply_transform(string & self, const transform_fn & fn) {
for (auto & part : self.parts) {
part.val = fn(part.val);
}
return self;
}
string string::uppercase() {
return apply_transform(*this, [](const std::string & s) {
std::string res = s;
std::transform(res.begin(), res.end(), res.begin(), ::toupper);
return res;
});
}
string string::lowercase() {
return apply_transform(*this, [](const std::string & s) {
std::string res = s;
std::transform(res.begin(), res.end(), res.begin(), ::tolower);
return res;
});
}
string string::capitalize() {
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;
});
}
string string::titlecase() {
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;
});
}
string string::strip(bool left, bool right, std::optional<const std::string_view> chars) {
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;
}
} // namespace jinja