cemplate

Simple C++ template engine
git clone git://git.dimitrijedobrota.com/cemplate.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit5c98605db5534f704898311e1dbfe06e275f1f4c
parentb52130ffd3fd9d9efdfa7eddeadc59d0cf9ca65d
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateThu, 13 Mar 2025 20:09:35 +0100

Some things should be free functions

Diffstat:
Minclude/cemplate/cemplate.hpp|+++++++++---------
Msource/cemplate.cpp|+++++++++++++++++-------------------

2 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/include/cemplate/cemplate.hpp b/include/cemplate/cemplate.hpp

@@ -123,7 +123,14 @@ static auto indent(std::size_t lvl)

return std::string(lvl * 2, ' ');
}
std::string string(const std::string& value);
using s_t = const std::string&;
using l_t = const std::vector<std::string>&;
using p_t = const std::vector<param_t>&;
using i_t = const InitlistNode&;
std::string string(s_t value);
std::string call(s_t func, l_t args);
std::string template_def(s_t var, l_t params);
class Program
{

@@ -133,17 +140,11 @@ public:

{
}
using s_t = const std::string&;
using l_t = const std::vector<std::string>&;
using p_t = const std::vector<param_t>&;
using i_t = const InitlistNode&;
// NOLINTBEGIN
Program& line_empty();
Program& line_value(s_t value);
Program& value(s_t value);
Program& string(s_t value);
Program& pragma(s_t value);
Program& include(s_t header);
Program& includeL(s_t header);

@@ -152,8 +153,8 @@ public:

Program& multilineComment(l_t values);
Program& call(s_t func, l_t args);
Program& call(s_t func, s_t args);
Program& statement(s_t content);
Program& ret(s_t value);
Program& declaration(s_t type, s_t name, s_t value);

@@ -161,7 +162,6 @@ public:

Program& require(s_t value);
Program& template_decl(l_t params);
Program& template_def(s_t var, l_t params);
Program& function_decl(s_t name, s_t ret, l_t params = {});

diff --git a/source/cemplate.cpp b/source/cemplate.cpp

@@ -25,6 +25,18 @@ std::string string(const std::string& value)

return std::format(R"("{}")", value);
}
std::string call(s_t func, l_t args)
{
return std::format(
"{}({})", func, join(std::begin(args), std::end(args), ", "));
}
std::string template_def(s_t var, l_t params)
{
return std::format(
"{}<{}>", var, join(std::begin(params), std::end(params), ", "));
}
Program& Program::line_empty()
{
m_ost << "\n";

@@ -43,12 +55,6 @@ Program& Program::value(s_t value)

return *this;
}
Program& Program::string(s_t value)
{
m_ost << ::cemplate::string(value);
return *this;
}
Program& Program::pragma(s_t value)
{
m_ost << std::format("#pragma {}\n", value);

@@ -82,17 +88,16 @@ Program& Program::multilineComment(l_t values)

return *this;
}
Program& Program::call(s_t func, l_t args)
Program& Program::call(s_t func, s_t args)
{
m_ost << std::format(
"{}({})", func, join(std::begin(args), std::end(args), ", "));
m_ost << std::format("{}{}({});\n", indent(), func, args);
return *this;
}
Program& Program::statement(s_t content)
Program& Program::call(s_t func, l_t args)
{
m_ost << std::format("{}{};\n", indent(), content);
return *this;
const std::string val = join(std::begin(args), std::end(args), ", ");
return call(func, val);
}
Program& Program::ret(s_t value)

@@ -133,13 +138,6 @@ Program& Program::template_decl(l_t params)

return *this;
}
Program& Program::template_def(s_t var, l_t params)
{
m_ost << std::format(
"{}<{}>", var, join(std::begin(params), std::end(params), ", "));
return *this;
}
Program& Program::function_decl(s_t name, s_t ret, l_t params)
{
m_ost << std::format("{} {}({});\n",