cemplate

Classes with conversion op might be the future * Accumulate function as utility * Initlist constructor with string * Func and func_decl * Tmplate and tmplate_spec * Call and rquires

4 files changed, 250 insertions(+), 57 deletions(-)

diff --git a/ CMakeLists.txt b/ CMakeLists.txt

@@ -4,7 +4,7 @@ include(cmake/prelude.cmake) project( cemplate

VERSION 0.1.6

VERSION 0.1.7

DESCRIPTION "Simple C++ template engine" HOMEPAGE_URL "https://git.dimitrijedobrota.com/cemplate.git" LANGUAGES CXX

diff --git a/ example/example.cpp b/ example/example.cpp

@@ -4,6 +4,7 @@ int main() {

using namespace std::string_literals; // NOLINT

using namespace cemplate; // NOLINT std::cout << pragma_once();

@@ -15,14 +16,18 @@ int main() std::cout << nspace("cemplate");

std::cout << func("test", "int", {});

std::cout << func("test", "int");

std::cout << ret("3"); std::cout << func("test");

std::cout << func("test", "void", {{"int", "val1"}, {"std::string", "val2"}});

std::cout << func("test", "void", {{{"int"s, "val1"s}}});

std::cout << func("test");

std::cout << func_decl("decl", "void", {});

std::cout << func(

"test", "void", {{"int"s, "val1"s}, {"std::string"s, "val2"s}});

std::cout << func("test");

std::cout << func_decl("decl", "void");

std::cout << '\n'; std::cout << "static const test_class test = ";

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

@@ -1,25 +1,46 @@ #pragma once #include <cstdint>

#include <functional>

#include <string> #include <variant>

#include <vector>

namespace cemplate {

struct param_t

template<typename T>

using transform_f = std::function<std::string(const T&)>;

template<typename T>

std::string to_string(const T& val)

{

std::string type;

std::string name;

};

return val;

}

template<typename T>

std::string accumulate(

const std::vector<T>& values,

const std::string& delim,

const transform_f<std::type_identity_t<T>>& transform = to_string<T>)

{

std::string res;

if (!values.empty()) {

res += transform(values[0]);

for (std::size_t i = 1; i < values.size(); i++) {

res += delim + transform(values[i]);

}

}

return res;

}

struct initlist_elem; struct initlist { std::string format(std::uint64_t lvl) const;

friend std::ostream& operator<<(std::ostream& ost, const initlist& list);

friend std::ostream& operator<<(std::ostream& ost, const initlist& rhs);

template<typename... Args> void emplace_back(Args... args)

@@ -63,6 +84,157 @@ private: std::variant<std::string, initlist> m_value; };

class func

{

public:

class param_t

{

public:

param_t(std::string type, std::string name)

: m_value(std::move(type) + " " + std::move(name))

{

}

explicit operator std::string() const { return m_value; }

const auto& value() const { return m_value; }

private:

std::string m_value;

};

explicit func(std::string name)

: m_name(std::move(name))

{

}

func(std::string name, std::string ret, const std::vector<param_t>& params)

: m_name(std::move(name))

, m_ret(std::move(ret))

, m_params(params.begin(), params.end())

{

}

func(std::string name, std::string ret, std::vector<std::string> params = {})

: m_name(std::move(name))

, m_ret(std::move(ret))

, m_params(std::move(params))

{

}

const auto& name() const { return m_name; }

const auto& ret() const { return m_ret; }

const auto& params() const { return m_params; }

friend std::ostream& operator<<(std::ostream& ost, const func& rhs);

private:

std::string m_name;

std::string m_ret;

std::vector<std::string> m_params;

};

class func_decl : public func

{

public:

func_decl(std::string name,

std::string ret,

const std::vector<param_t>& params)

: func(std::move(name), std::move(ret), params)

{

}

func_decl(std::string name,

std::string ret,

std::vector<std::string> params = {})

: func(std::move(name), std::move(ret), std::move(params))

{

}

friend std::ostream& operator<<(std::ostream& ost, const func_decl& rhs);

};

class call

{

public:

call(std::string func, std::string args)

: m_func(std::move(func))

, m_args(std::move(args))

{

}

operator std::string() const; // NOLINT

friend std::ostream& operator<<(std::ostream& ost, const call& rhs);

protected:

const auto& func() const { return m_func; }

const auto& args() const { return m_args; }

private:

std::string m_func;

std::string m_args;

};

class call_s : public call

{

public:

call_s(std::string func, std::string args)

: call(std::move(func), std::move(args))

{

}

operator std::string() const; // NOLINT

friend std::ostream& operator<<(std::ostream& ost, const call_s& rhs);

};

class tmplate

{

public:

explicit tmplate(std::vector<std::string> params)

: m_params(std::move(params))

{

}

operator std::string() const; // NOLINT

friend std::ostream& operator<<(std::ostream& ost, const tmplate& rhs);

private:

std::vector<std::string> m_params;

};

class tmplate_spec

{

public:

explicit tmplate_spec(std::string var, std::string param)

: m_var(std::move(var))

, m_param(std::move(param))

{

}

operator std::string() const; // NOLINT

friend std::ostream& operator<<(std::ostream& ost, const tmplate_spec& rhs);

private:

std::string m_var;

std::string m_param;

};

class rquires

{

public:

explicit rquires(std::string value)

: m_value(std::move(value))

{

}

operator std::string() const; // NOLINT

friend std::ostream& operator<<(std::ostream& ost, const rquires& rhs);

private:

std::string m_value;

};

std::string pragma_once(); std::string include(const std::string& header, bool local = false);

@@ -75,12 +247,4 @@ std::string string(const std::string& string); std::string decl(const std::string& type, const std::string& name);

std::string func(const std::string& name,

const std::string& ret = "",

const std::vector<param_t>& params = {});

std::string func_decl(const std::string& name,

const std::string& ret = "",

const std::vector<param_t>& params = {});

} // namespace cemplate

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

@@ -1,5 +1,4 @@ #include <format>

#include <functional>

#include <iostream> #include <stack> #include <unordered_set>

@@ -25,23 +24,6 @@ void warning(const std::string& message, const std::string& addition) // NOLINT std::cerr << '\n' << std::flush; }

template<typename T>

std::string accumulate(const std::vector<T>& values,

const std::function<std::string(const T&)>& format,

const std::string& delim)

{

std::string res;

if (!values.empty()) {

res += format(values[0]);

for (std::size_t i = 1; i < values.size(); i++) {

res += delim + format(values[i]);

}

}

return res;

}

} // namespace namespace cemplate

@@ -94,6 +76,26 @@ std::string decl(const std::string& type, const std::string& name) return std::format("{}{} {} = ", indent(), type, name); }

call::operator std::string() const

{

return std::format("{}({})", func(), args());

}

std::ostream& operator<<(std::ostream& ost, const call& rhs)

{

return ost << static_cast<std::string>(rhs);

}

call_s::operator std::string() const

{

return std::format("{}{}({});\n", indent(), func(), args());

}

std::ostream& operator<<(std::ostream& ost, const call_s& rhs)

{

return ost << static_cast<std::string>(rhs);

}

std::string eval(const std::string& val, std::uint64_t lvl); // NOLINT std::string eval(const initlist& list, std::uint64_t lvl); // NOLINT

@@ -120,53 +122,75 @@ std::string eval(const std::string& val, std::uint64_t lvl) return std::format("{}{},\n", indent(lvl), val); }

std::ostream& operator<<(std::ostream& ost, const initlist& list)

std::ostream& operator<<(std::ostream& ost, const initlist& rhs)

{ return ost << std::format(

"{{\n{}{}}};\n", list.format(indent_lvl + 1), indent());

"{{\n{}{}}};\n", rhs.format(indent_lvl + 1), indent());

} std::string func_helper(const std::string& name, // NOLINT const std::string& ret,

const std::vector<param_t>& params)

const std::vector<std::string>& params)

{

static const auto format = [](const param_t& param)

{ return param.name.empty() ? param.type : param.type + ' ' + param.name; };

return std::format(

"{} {}({})", ret, name, accumulate<param_t>(params, format, ", "));

return std::format("{} {}({})", ret, name, accumulate(params, ", "));

}

std::string func(const std::string& name,

const std::string& ret,

const std::vector<param_t>& params)

std::ostream& operator<<(std::ostream& ost, const func& rhs)

{ static std::string last; if (last.empty()) {

if (ret.empty()) {

warning("function should have a return type", name);

if (rhs.ret().empty()) {

warning("function should have a return type", rhs.name());

}

last = name;

last = rhs.name();

indent_lvl++;

return func_helper(name, ret, params) + " {\n";

return ost << func_helper(rhs.name(), rhs.ret(), rhs.params()) + "\n{\n";

}

if (last != name) {

if (last != rhs.name()) {

warning("function is not closed", last); } last.clear(); indent_lvl--;

return "}\n\n";

return ost << "}\n\n";

}

std::ostream& operator<<(std::ostream& ost, const func_decl& rhs)

{

return ost << func_helper(rhs.name(), rhs.ret(), rhs.params()) + ";\n";

}

tmplate::operator std::string() const

{

return std::format("{}template <{}>\n", indent(), accumulate(m_params, ","));

}

std::ostream& operator<<(std::ostream& ost, const tmplate& rhs)

{

return ost << static_cast<std::string>(rhs);

}

tmplate_spec::operator std::string() const

{

return std::format("{}<{}>", m_var, m_param);

}

std::ostream& operator<<(std::ostream& ost, const tmplate_spec& rhs)

{

return ost << static_cast<std::string>(rhs);

}

rquires::operator std::string() const

{

return std::format("{}requires {}\n", indent(indent_lvl + 1), m_value);

}

std::string func_decl(const std::string& name,

const std::string& ret,

const std::vector<param_t>& params)

std::ostream& operator<<(std::ostream& ost, const rquires& rhs)

{

return func_helper(name, ret, params) + ";\n";

return ost << static_cast<std::string>(rhs);

} } // namespace cemplate