cemplate

Fix naming and put everything in a class

5 files changed, 290 insertions(+), 167 deletions(-)

diff --git a/ .clang-tidy b/ .clang-tidy

@@ -57,7 +57,7 @@ CheckOptions: - key: 'readability-identifier-naming.AbstractClassCase' value: 'lower_case' - key: 'readability-identifier-naming.ClassCase'

value: 'lower_case'

value: 'CamelCase'

- key: 'readability-identifier-naming.ClassConstantCase' value: 'lower_case' - key: 'readability-identifier-naming.ClassMemberCase'

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

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

VERSION 0.1.7

VERSION 0.1.8

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

@@ -7,33 +7,33 @@ int main() using namespace std::string_literals; // NOLINT using namespace cemplate; // NOLINT

std::cout << pragma_once();

std::cout << Pragma("once") << '\n';

std::cout << include("format");

std::cout << include("iostream");

std::cout << include("string");

std::cout << Include("format");

std::cout << Include("iostream");

std::cout << Include("string");

std::cout << '\n';

std::cout << nspace("cemplate");

std::cout << Namespace("cemplate");

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

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

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

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

std::cout << Return("3");

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

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

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

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

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

std::cout << func(

std::cout << Function(

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

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

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

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

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

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

std::cout << initlist({"val11", "val12", {"val21", "val22"}, "val13"});

std::cout << Initlist({"val11", "val12", {"val21", "val22"}, "val13"});

std::cout << nspace("cemplate");

std::cout << Namespace("cemplate");

return 0; }

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

@@ -18,7 +18,7 @@ std::string to_string(const T& val) } template<typename T>

std::string accumulate(

std::string join(

const std::vector<T>& values, const std::string& delim, const transform_f<std::type_identity_t<T>>& transform = to_string<T>)

@@ -35,12 +35,15 @@ std::string accumulate( return res; }

struct initlist_elem;

class InitlistElem;

struct initlist

class Initlist

{

std::string format(std::uint64_t lvl) const;

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

public:

std::string format(uint64_t lvl) const;

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

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

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

@@ -48,32 +51,33 @@ struct initlist values.emplace_back(std::forward<Args>(args)...); }

std::vector<initlist_elem> values; // NOLINT

std::vector<InitlistElem> values; // NOLINT

};

struct initlist_elem

class InitlistElem

{

initlist_elem(std::string value) // NOLINT

public:

InitlistElem(std::string value) // NOLINT

: m_value(std::move(value)) { }

initlist_elem(std::string_view value) // NOLINT

InitlistElem(std::string_view value) // NOLINT

: m_value(std::in_place_type<std::string>, value) { }

initlist_elem(const char* value) // NOLINT

InitlistElem(const char* value) // NOLINT

: m_value(value) { }

initlist_elem(std::initializer_list<initlist_elem> list) // NOLINT

: m_value(std::in_place_type<initlist>, list)

InitlistElem(std::initializer_list<InitlistElem> list) // NOLINT

: m_value(std::in_place_type<Initlist>, list)

{ }

initlist_elem(initlist list) // NOLINT

InitlistElem(Initlist list) // NOLINT

: m_value(std::move(list)) { }

@@ -81,21 +85,20 @@ struct initlist_elem const auto& value() const { return m_value; } private:

std::variant<std::string, initlist> m_value;

std::variant<std::string, Initlist> m_value;

};

class func

class Function

{ public:

class param_t

struct 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; }

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

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

@@ -103,30 +106,34 @@ public: std::string m_value; };

explicit func(std::string name)

explicit Function(std::string name)

: m_name(std::move(name)) { }

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

Function(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 = {})

Function(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);

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

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

private: std::string m_name;

@@ -134,37 +141,44 @@ private: std::vector<std::string> m_params; };

class func_decl : public func

class FunctionD : public Function

{ public:

func_decl(std::string name,

FunctionD(std::string name,

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

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

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

{ }

func_decl(std::string name,

FunctionD(std::string name,

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

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

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

{ }

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

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

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

};

class call

class Call

{ public:

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

Call(std::string func, std::vector<std::string> args)

: m_func(std::move(func)) , m_args(std::move(args)) { }

Call(std::string func, std::string arg)

: m_func(std::move(func))

, m_args({std::move(arg)})

{

}

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

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

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

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

@@ -172,79 +186,219 @@ protected: private: std::string m_func;

std::string m_args;

std::vector<std::string> m_args;

};

class call_s : public call

class Statement

{ public:

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

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

explicit Statement(std::string content)

: m_content(std::move(content))

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

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

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

private:

std::string m_content;

};

class tmplate

class Template

{ public:

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

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

: m_params(std::move(params)) { }

explicit Template(std::string param)

: m_params({std::move(param)})

{

}

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

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

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

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

class tmplate_spec

class TemplateD

{ public:

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

TemplateD(std::string var, std::vector<std::string> params)

: m_var(std::move(var))

, m_param(std::move(param))

, m_params(std::move(params))

{

}

TemplateD(std::string var, std::string param)

: m_var(std::move(var))

, m_params({std::move(param)})

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

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

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

private: std::string m_var;

std::string m_param;

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

};

class Requires

{

public:

explicit Requires(std::string value)

: m_value(std::move(value))

{

}

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

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

private:

std::string m_value;

};

class Pragma

{

public:

explicit Pragma(std::string value)

: m_value(std::move(value))

{

}

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

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

private:

std::string m_value;

};

class Include

{

public:

explicit Include(std::string header)

: m_header(std::move(header))

{

}

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

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

private:

std::string m_header;

};

class IncludeL

{

public:

explicit IncludeL(std::string header)

: m_header(std::move(header))

{

}

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

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

private:

std::string m_header;

};

class rquires

class Namespace

{ public:

explicit rquires(std::string value)

explicit Namespace(std::string name)

: m_name(std::move(name))

{

}

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

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

private:

std::string m_name;

};

class Return

{

public:

explicit Return(std::string value)

: m_value(std::move(value)) { } operator std::string() const; // NOLINT

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

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

private: std::string m_value; };

std::string pragma_once();

class Declaration

{

public:

Declaration(std::string type, std::string name, std::string value)

: m_type(std::move(type))

, m_name(std::move(name))

, m_value(std::move(value))

{

}

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

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

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

std::string nspace(const std::string& name);

private:

std::string m_type;

std::string m_name;

std::string m_value;

};

std::string ret(const std::string& val);

class String

{

public:

explicit String(std::string value)

: m_value(std::move(value))

{

}

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

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

private:

std::string m_value;

};

std::string string(const std::string& string);

template<typename T, int key>

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

{

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

}

std::string decl(const std::string& type, const std::string& name);

// NOLINTBEGIN

#define DEF_OST(typename) \

inline std::ostream& operator<<(std::ostream& ost, const typename& rhs) \

{ \

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

}

// NOLINTEND

DEF_OST(Initlist)

DEF_OST(Function)

DEF_OST(FunctionD)

DEF_OST(Call)

DEF_OST(Statement)

DEF_OST(Template)

DEF_OST(TemplateD)

DEF_OST(Requires)

DEF_OST(Pragma)

DEF_OST(Include)

DEF_OST(IncludeL)

DEF_OST(Namespace)

DEF_OST(Return)

DEF_OST(Declaration)

DEF_OST(String)

} // namespace cemplate

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

@@ -29,168 +29,137 @@ void warning(const std::string& message, const std::string& addition) // NOLINT namespace cemplate {

std::string pragma_once()

Pragma::operator std::string() const

{

return "#pragma once\n\n";

return std::format("#pragma {}\n", m_value);

}

std::string include(const std::string& header, bool local)

Include::operator std::string() const

{

return local ? std::format("#include \"{}\"\n", header)

: std::format("#include <{}>\n", header);

return std::format("#include <{}>\n", m_header);

}

std::string nspace(const std::string& name)

IncludeL::operator std::string() const

{

return std::format("#include \"{}\"\n", m_header);

}

Namespace::operator std::string() const

{ static std::unordered_set<std::string> seen; static std::stack<std::string> stk;

if (stk.empty() || stk.top() != name) {

if (seen.contains(name)) {

warning("nesting namespaces of the same name", name);

if (stk.empty() || stk.top() != m_name) {

if (seen.contains(m_name)) {

warning("nesting namespaces of the same name", m_name);

}

seen.insert(name);

stk.push(name);

seen.insert(m_name);

stk.push(m_name);

return std::format("namespace {}\n{{\n\n", name);

return std::format("namespace {}\n{{\n\n", m_name);

}

seen.erase(name);

seen.erase(m_name);

stk.pop();

return std::format("\n}} // namespace {}\n\n", name);

return std::format("\n}} // namespace {}\n\n", m_name);

}

std::string ret(const std::string& val)

Return::operator std::string() const

{

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

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

}

std::string string(const std::string& string)

String::operator std::string() const

{

return std::format(R"("{}")", string);

return std::format(R"("{}")", m_value);

}

std::string decl(const std::string& type, const std::string& name)

Declaration::operator std::string() const

{

return std::format("{}{} {} = ", indent(), type, name);

return std::format("{}{} {} = {};\n", indent(), m_type, m_name, m_value);

}

call::operator std::string() const

Call::operator std::string() const

{

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

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

}

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

Statement::operator std::string() const

{

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

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

}

call_s::operator std::string() const

std::string Initlist::format(uint64_t lvl) 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

const auto eval = []<typename T>(const T& val, std::uint64_t llvl)

{

if constexpr (std::is_same_v<T, std::string>) {

return std::format("{}{},\n", indent(llvl), val);

} else if (std::is_same_v<T, Initlist>) {

return std::format(

"{}{{\n{}{}}},\n", indent(llvl), val.format(llvl + 1), indent(llvl));

} else {

return std::string();

}

};

std::string initlist::format(uint64_t lvl) const

{

std::string res;

for (const auto& node : values) {

std::visit([&](const auto& value) { res += eval(value, lvl + 1); },

node.value());

for (const auto& elem : values) {

std::visit([&](const auto& val) { res += eval(val, lvl + 1); },

elem.value());

} return res; }

std::string eval(const initlist& list, std::uint64_t lvl)

{

return std::format(

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

}

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& rhs)

Initlist::operator std::string() const

{

return ost << std::format(

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

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

}

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

const std::string& ret,

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

{

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

}

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

Function::operator std::string() const

{ static std::string last;

if (last.empty()) {

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

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

if (!last.empty()) {

if (last != name()) {

warning("function is not closed", last);

}

last = rhs.name();

indent_lvl++;

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

last.clear();

indent_lvl--;

return "}\n\n";

}

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

warning("function is not closed", last);

if (ret().empty()) {

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

}

last.clear();

indent_lvl--;

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, ","));

last = name();

indent_lvl++;

return std::format("{} {}({})\n{{\n", ret(), name(), join(params(), ", "));

}

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

FunctionD::operator std::string() const

{

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

return std::format("{} {}({});\n", ret(), name(), join(params(), ", "));

}

tmplate_spec::operator std::string() const

Template::operator std::string() const

{

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

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

}

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

TemplateD::operator std::string() const

{

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

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

}

rquires::operator std::string() const

Requires::operator std::string() const

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

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

{

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

}

} // namespace cemplate