cemplate

Improve consistency

3 files changed, 109 insertions(+), 87 deletions(-)

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

@@ -34,8 +34,7 @@ int main() .function_decl("decl", "void") .line_empty()

.line_value("static const test_class test = ")

.Initlist({"val11", "val12", {"val21", "val22"}, "val13"})

.declaration("static const test_class", "test", {"val11", "val12", {"val21", "val22"}, "val13"})

.namespace_close("cemplate"); // clang-format on

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

@@ -51,83 +51,92 @@ std::string join(std::initializer_list<T> list, return join(std::begin(list), std::end(list), delim, func); }

class Program

struct param_t

{

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

: m_value(type + " " + name)

{

}

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

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

private:

std::string m_value;

};

class InitlistElem;

class InitlistNode

{ public:

using s_t = const std::string&;

using l_t = const std::vector<std::string>&;

InitlistNode(std::initializer_list<InitlistElem> list);

explicit Program(std::ostream& ost)

: m_ost(ost)

template<typename InputItr, typename UnaryFunc>

InitlistNode(InputItr first, InputItr last, UnaryFunc func);

std::string format(uint64_t lvl) const;

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

private:

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

};

class InitlistElem

{

public:

InitlistElem(std::string value) // NOLINT

: m_value(std::move(value))

{ }

struct param_t

InitlistElem(std::string_view value) // NOLINT

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

{

param_t(s_t type, s_t name)

: m_value(type + " " + name)

{

}

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

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

}

private:

std::string m_value;

};

InitlistElem(const char* value) // NOLINT

: m_value(value)

{

}

class InitlistElem;

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

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

{

}

class InitlistNode

InitlistElem(InitlistNode list) // NOLINT

: m_value(std::move(list))

{

public:

InitlistNode(std::initializer_list<InitlistElem> list);

}

template<typename InputItr, typename UnaryFunc>

InitlistNode(InputItr first, InputItr last, UnaryFunc func);

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

std::string format(uint64_t lvl) const;

private:

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

};

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

static auto indent(std::size_t lvl)

{

return std::string(lvl * 2, ' ');

}

private:

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

};

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

class InitlistElem

class Program

{

public:

explicit Program(std::ostream& ost)

: m_ost(ost)

{

public:

InitlistElem(std::string value) // NOLINT

: m_value(std::move(value))

{

}

InitlistElem(std::string_view value) // NOLINT

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

{

}

InitlistElem(const char* value) // NOLINT

: m_value(value)

{

}

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

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

{

}

InitlistElem(InitlistNode list) // NOLINT

: m_value(std::move(list))

{

}

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

private:

std::variant<std::string, InitlistNode> m_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&;

// NOLINTBEGIN Program& line_empty();

@@ -148,6 +157,7 @@ public: Program& ret(s_t value); Program& declaration(s_t type, s_t name, s_t value);

Program& declaration(s_t type, s_t name, i_t value);

Program& require(s_t value); Program& template_decl(l_t params);

@@ -156,26 +166,31 @@ public: Program& function_decl(s_t name, s_t ret, l_t params = {}); Program& function_open(s_t name, s_t ret, l_t params = {});

Program& function_close(s_t name);

Program& namespace_open(s_t name);

Program& namespace_close(s_t name);

// NOLINTEND

Program& function_open(s_t name, s_t ret, const std::vector<param_t>& params)

Program& function_open(s_t name, s_t ret, p_t params)

{ return function_open( name, ret, std::vector<std::string>(std::begin(params), std::end(params))); }

Program& function_close(s_t name);

Program& namespace_open(s_t name);

Program& namespace_close(s_t name);

Program& Initlist(const InitlistNode& node);

// NOLINTEND

Program& function_decl(s_t name, s_t ret, p_t params)

{

return function_decl(

name,

ret,

std::vector<std::string>(std::begin(params), std::end(params)));

}

private:

static auto indent(std::size_t lvl) { return std::string(lvl * 2, ' '); }

std::string indent() const { return indent(m_indent); }

std::string indent() const { return ::cemplate::indent(m_indent); }

std::size_t m_indent = 0;

@@ -190,16 +205,13 @@ private: std::ostream& m_ost; // NOLINT };

inline Program::InitlistNode::InitlistNode(

std::initializer_list<InitlistElem> list)

inline InitlistNode::InitlistNode(std::initializer_list<InitlistElem> list)

: m_values(list) { } template<typename InputItr, typename UnaryFunc>

Program::InitlistNode::InitlistNode(InputItr first,

InputItr last,

UnaryFunc func)

InitlistNode::InitlistNode(InputItr first, InputItr last, UnaryFunc func)

{ m_values.reserve(last - first); std::for_each(

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

@@ -20,6 +20,11 @@ void warning(const std::string& message, const std::string& addition) // NOLINT namespace cemplate {

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

{

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

}

Program& Program::line_empty() { m_ost << "\n";

@@ -40,7 +45,7 @@ Program& Program::value(s_t value) Program& Program::string(s_t value) {

m_ost << std::format(R"("{}")", value);

m_ost << ::cemplate::string(value);

return *this; }

@@ -92,7 +97,7 @@ Program& Program::statement(s_t content) Program& Program::ret(s_t value) {

m_ost << std::format("{}m_ost << {};\n", indent(), value);

m_ost << std::format("{}return {};\n", indent(), value);

return *this; }

@@ -102,9 +107,21 @@ Program& Program::declaration(s_t type, s_t name, s_t value) return *this; }

Program& Program::declaration(s_t type, s_t name, i_t value)

{

m_ost << std::format("{}{} {} = {{\n{}{}}};\n",

indent(),

type,

name,

value.format(m_indent + 1),

indent());

return *this;

}

Program& Program::require(s_t value) {

m_ost << std::format("{}requires {}\n", indent(m_indent + 1), value);

m_ost << std::format(

"{}requires {}\n", ::cemplate::indent(m_indent + 1), value);

return *this; }

@@ -132,7 +149,7 @@ Program& Program::function_decl(s_t name, s_t ret, l_t params) return *this; }

std::string Program::InitlistNode::format(uint64_t lvl) const

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

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

@@ -154,12 +171,6 @@ std::string Program::InitlistNode::format(uint64_t lvl) const return res; }

Program& Program::Initlist(const InitlistNode& node)

{

m_ost << std::format("{{\n{}{}}}", node.format(m_indent + 1), indent());

return *this;

}

Program& Program::function_open(s_t name, s_t ret, l_t params) { if (!m_function_last.empty()) {