Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add string node #1630

Merged
merged 5 commits into from
Dec 15, 2023
Merged

Add string node #1630

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
5c20762
add more string node
Ashheer Dec 14, 2023
dba5d31
add find and replace str
Ashheer Dec 15, 2023
c1ef24f
some simple stringnode
Ashheer Dec 15, 2023
86daedb
literally all string node
Ashheer Dec 15, 2023
cb55cb0
small improve
Ashheer Dec 15, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
287 changes: 283 additions & 4 deletions zeno/src/nodes/StringNodes.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,10 @@
#include <zeno/types/ListObject.h>
#include <zeno/extra/GlobalState.h>
#include <zeno/types/ListObject.h>
#include <zeno/utils/string.h>
#include <string_view>
#include <regex>
#include <filesystem>

namespace zeno {
namespace {
Expand Down Expand Up @@ -387,7 +390,6 @@ ZENDEFNODE(EndFrame, {
});*/

struct StringToNumber : zeno::INode {

virtual void apply() override {
auto in_str = get_input2<std::string>("str");
auto type = get_input2<std::string>("type");
Expand All @@ -410,7 +412,7 @@ struct StringToNumber : zeno::INode {

ZENDEFNODE(StringToNumber, {{
/* inputs: */
{"enum float int", "type", "all"},
{"enum float int", "type", "float"},
{"string", "str", "0"},
},

Expand Down Expand Up @@ -446,21 +448,22 @@ struct StringToList : zeno::INode {
auto list = std::make_shared<ListObject>();
auto separator = get_input2<std::string>("Separator");
auto trimoption = get_input2<bool>("Trim");
auto keepempty = get_input2<bool>("KeepEmpty");
std::vector<std::string> strings;
size_t pos = 0;
size_t posbegin = 0;
std::string word;
while ((pos = stringlist.find(separator, pos)) != std::string::npos) {
word = stringlist.substr(posbegin, pos-posbegin);
if(trimoption) trim(word);
strings.push_back(word);
if(keepempty || !word.empty()) strings.push_back(word);
pos += separator.length();
posbegin = pos;
}
if (posbegin < stringlist.length()) { //push last word
word = stringlist.substr(posbegin);
if(trimoption) trim(word);
strings.push_back(word);
if(keepempty || !word.empty()) strings.push_back(word);
}
for(const auto &string : strings) {
auto obj = std::make_unique<StringObject>();
Expand All @@ -476,12 +479,288 @@ ZENDEFNODE(StringToList, {
{"multiline_string", "string", ""},
{"string", "Separator", ""},
{"bool", "Trim", "false"},
{"bool", "KeepEmpty", "false"},
},
{{"list"},
},
{},
{"string"},
});

struct StringJoin : zeno::INode {//zeno string only support list for now
virtual void apply() override {
auto list = get_input<zeno::ListObject>("list");
auto stringvec = list->get2<std::string>();
auto separator = get_input2<std::string>("Separator");
auto output = join_str(stringvec, separator);
set_output2("string", output);
}
};

ZENDEFNODE(StringJoin, {
{
{"list"},
{"string", "Separator", ""},
},
{{"string", "string"},
},
{},
{"string"},
});

struct NumbertoString : zeno::INode {
virtual void apply() override {
auto num = get_input<zeno::NumericObject>("number");
auto obj = std::make_unique<zeno::StringObject>();
std::visit([&](const auto &v) {
obj->set(zeno::to_string(v));
}, num->value);
set_output("string", std::move(obj));
}
};

ZENDEFNODE(NumbertoString, {
{
{"number"},
},
{{"string", "string"},
},
{},
{"string"},
});

std::string strreplace(std::string textToSearch, std::string_view toReplace, std::string_view replacement)
{
size_t pos = 0;
for (;;)
{
pos = textToSearch.find(toReplace, pos);
if (pos == std::string::npos)
return textToSearch;
textToSearch.replace(pos, toReplace.length(), replacement);
pos += replacement.length();
}
}

struct StringReplace : zeno::INode {
virtual void apply() override {
std::string string = get_input2<std::string>("string");
std::string oldstr = get_input2<std::string>("old");
std::string newstr = get_input2<std::string>("new");
auto output = strreplace(string, oldstr, newstr);
set_output2("string", output);
}
};

ZENDEFNODE(StringReplace, {
{
{"multiline_string", "string", ""},
{"string", "old", ""},
{"string", "new", ""},
},
{{"string", "string"},
},
{},
{"string"},
});

struct StringFind : zeno::INode {//return -1 if not found
virtual void apply() override {
auto string = get_input2<std::string>("string");
auto substring = get_input2<std::string>("substring");
auto start = get_input2<int>("start");
std::string::size_type n = string.find(substring, start);
int output = (n == std::string::npos) ? -1 : static_cast<int>(n);
set_output2("Position", output);
}
};

ZENDEFNODE(StringFind, {
{
{"multiline_string", "string", ""},
{"string", "substring", ""},
{"int", "start", "0"},
},
{{"int", "Position"},
},
{},
{"string"},
});

struct SubString : zeno::INode {//slice...
virtual void apply() override {
auto string = get_input2<std::string>("string");
auto start = get_input2<int>("start");
auto length = get_input2<int>("length");
auto output = string.substr(start, length);
set_output2("string", output);
}
};

ZENDEFNODE(SubString, {
{
{"multiline_string", "string", ""},
{"int", "start", "0"},
{"int", "length", "1"},
},
{{"string", "string"},
},
{},
{"string"},
});

struct StringtoLower : zeno::INode {
virtual void apply() override {
auto string = get_input2<std::string>("string");
std::string output = string;
std::transform(output.begin(), output.end(), output.begin(), [] (auto c) {
return static_cast<char> (std::tolower (static_cast<unsigned char> (c))); });
set_output2("string", output);
}
};

ZENDEFNODE(StringtoLower, {
{
{"string", "string", ""},
},
{{"string", "string"},
},
{},
{"string"},
});

struct StringtoUpper : zeno::INode {
virtual void apply() override {
auto string = get_input2<std::string>("string");
std::string output = string;
std::transform(output.begin(), output.end(), output.begin(), [] (auto c) {
return static_cast<char> (std::toupper (static_cast<unsigned char> (c))); });
set_output2("string", output);
}
};

ZENDEFNODE(StringtoUpper, {
{
{"string", "string", ""},
},
{{"string", "string"},
},
{},
{"string"},
});

struct StringLength : zeno::INode {
virtual void apply() override {
auto string = get_input2<std::string>("string");
int output = string.length();
set_output2("length", output);
}
};

ZENDEFNODE(StringLength, {
{
{"string", "string", ""},
},
{{"int", "length"},
},
{},
{"string"},
});

struct StringSplitPath : zeno::INode {
virtual void apply() override {
auto string = get_input2<std::string>("string");
bool SplitExtension = get_input2<bool>("SplitExtension");
std::string directory, filename, extension;
std::filesystem::path p(string);
directory = p.parent_path().string();
filename = p.stem().string();
extension = p.extension().string();
if(!SplitExtension) filename += extension;//extension output is empty if SplitExtension is false
set_output2("directory", directory);
set_output2("filename", filename);
set_output2("extension", extension);
}
};

ZENDEFNODE(StringSplitPath, {
{
{"readpath", "string", ""},
{"bool", "SplitExtension", "true"},
},
{{"string", "directory"},
{"string", "filename"},
{"string", "extension"},
},
{},
{"string"},
});

struct StringInsert : zeno::INode {//if start is greater than string length, insert at the end; if start is less than 0, reverse counting from the end
virtual void apply() override {
auto string = get_input2<std::string>("string");
auto substring = get_input2<std::string>("substring");
auto start = get_input2<int>("start");
auto output = string;
if (start < 0) {
start = output.size() + start;
if (start < 0) {
start = 0;
}
} else if (start > output.size()) {
start = output.size();
}
output.insert(start, substring);
set_output2("string", output);
}
};

ZENDEFNODE(StringInsert, {
{
{"multiline_string", "string", ""},
{"string", "substring", ""},
{"int", "start", "0"},
},
{{"string", "string"},
},
{},
{"string"},
});

struct StringTrim : zeno::INode {
virtual void apply() override {
auto string = get_input2<std::string>("string");
auto trimleft = get_input2<bool>("trimleft");
auto trimright = get_input2<bool>("trimright");
std::string output = string;
if (!output.empty()) {
if (trimleft) {
output.erase(output.begin(), std::find_if(output.begin(), output.end(), [](int ch) {
return !std::isspace(ch);
}));
}
if (trimright) {
output.erase(std::find_if(output.rbegin(), output.rend(), [](int ch) {
return !std::isspace(ch);
}).base(), output.end());
}
}
set_output2("string", output);

}
};

ZENDEFNODE(StringTrim, {
{
{"string", "string", ""},
{"bool", "trimleft", "true"},
{"bool", "trimright", "true"},
},
{{"string", "string"},
},
{},
{"string"},
});

}
}
2 changes: 1 addition & 1 deletion zeno/src/nodes/prim/WBTestFunction.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -295,7 +295,7 @@ ZENDEFNODE(str2num, {
},
/* category: */
{
"WBTest",
"deprecated",
}});


Expand Down
Loading