stamen

Shuffle the code around

8 files changed, 229 insertions(+), 225 deletions(-)

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

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

VERSION 1.2.5

VERSION 1.2.6

DESCRIPTION "Static menu generator" HOMEPAGE_URL "https://git.dimitrijedobrota.com/stamen" LANGUAGES C CXX

@@ -20,7 +20,7 @@ find_package(cemplate 0.1.6 CONFIG REQUIRED) add_library( stamen_stamen

source/menu.cpp

source/stamen.cpp

) target_link_libraries(stamen_stamen PUBLIC poafloc::poafloc) add_library(stamen::stamen ALIAS stamen_stamen)

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

@@ -2,12 +2,13 @@ #include <cstddef> #include <format> #include <iostream>

#include <limits>

#include <span>

#include "stamen/menu.hpp"

#include "stamen/stamen.hpp"

namespace {

int display(const stamen::menu::menu_t& menu)

int display(const stamen::menu_t& menu)

{ const int sizei = static_cast<int>(menu.items().size()); const size_t dgts = static_cast<size_t>(std::log10(sizei)) + 1;

@@ -58,26 +59,26 @@ int display(const stamen::menu::menu_t& menu) return 1; }

int finish(std::size_t /* unused */) // NOLINT

int finish(std::size_t /* unused */)

{

exit(0);

exit(0); // NOLINT

}

int operation1(std::size_t /* unused */) // NOLINT

int operation1(std::size_t /* unused */)

{ std::cout << "1\n"; std::cout << std::flush; return 1; }

int operation2(std::size_t /* unused */) // NOLINT

int operation2(std::size_t /* unused */)

{ std::cout << "2\n"; std::cout << std::flush; return 1; }

int operation3(std::size_t /* unused */) // NOLINT

int operation3(std::size_t /* unused */)

{ std::cout << "3\n"; std::cout << std::flush;

@@ -91,16 +92,16 @@ int main(int argc, char* argv[]) const std::span args(argv, argv + argc); // read the configuration

for (const auto& arg : args.subspan(1)) stamen::menu::read(arg);

for (const auto& arg : args.subspan(1)) stamen::read(arg);

// register free functions

stamen::menu::insert("finish", finish);

stamen::menu::insert("operation1", operation1);

stamen::menu::insert("operation2", operation2);

stamen::menu::insert("operation3", operation3);

stamen::insert("finish", finish);

stamen::insert("operation1", operation1);

stamen::insert("operation2", operation2);

stamen::insert("operation3", operation3);

// start the menu on specific panel

stamen::menu::dynamic("menu_main", display);

stamen::dynamic("menu_main", display);

return 0; }

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

@@ -2,6 +2,7 @@ #include <cstddef> #include <format> #include <iostream>

#include <limits>

#include "demo_menu.hpp"

diff --git a/ include/stamen/menu.hpp b/ include/stamen/menu.hpp

@@ -1,89 +0,0 @@

#pragma once

#include <cstring>

#include <functional>

#include <string>

#include <unordered_map>

#include <vector>

namespace stamen::menu {

class menu_t;

using callback_f = std::function<int(size_t)>;

using display_f = std::function<int(const menu_t&)>;

struct item_t

{

callback_f callback;

std::string prompt;

};

// NOLINTBEGIN

extern std::unordered_map<std::string, callback_f> free_lookup;

extern std::unordered_map<std::string, menu_t> menu_lookup;

extern std::string display_stub_default;

// NOLINTEND

void read(const char* filename);

void insert(const char* code, const callback_f& callback);

int dynamic(const char* code, const display_f& disp);

int display_stub(std::size_t idx);

class menu_t

{

struct private_ctor_t

{

};

friend void read(const char* filename);

public:

// Tag type dispatch

menu_t(private_ctor_t, // NOLINT

const std::string& code,

const std::string& prompt)

: menu_t(code, prompt)

{

}

menu_t(const menu_t&) = delete;

menu_t& operator=(const menu_t&) = delete;

menu_t(menu_t&&) = delete;

menu_t& operator=(menu_t&&) = delete;

~menu_t() = default;

const std::string& code() const { return m_code; }

const std::string& title() const { return m_title; }

const auto& items() const { return m_items; }

auto& items() { return m_items; }

auto get_callback(std::size_t idx) const { return m_items[idx].callback; }

const auto& get_code(std::size_t idx) const { return m_codes[idx].code; }

const auto& get_prompt(std::size_t idx) const { return m_codes[idx].prompt; }

private:

menu_t(std::string code, std::string prompt)

: m_code(std::move(code))

, m_title(std::move(prompt))

{

}

void insert(const std::string& code,

const std::string& prompt,

const callback_f& callback = display_stub);

struct code_t

{

std::string code;

std::string prompt;

};

std::string m_code;

std::string m_title;

std::vector<code_t> m_codes;

std::vector<item_t> m_items;

};

} // namespace stamen::menu

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

@@ -0,0 +1,89 @@

#pragma once

#include <cstring>

#include <functional>

#include <string>

#include <unordered_map>

#include <vector>

namespace stamen {

class menu_t;

using callback_f = std::function<int(size_t)>;

using display_f = std::function<int(const menu_t&)>;

struct item_t

{

callback_f callback;

std::string prompt;

};

// NOLINTBEGIN

extern std::unordered_map<std::string, callback_f> free_lookup;

extern std::unordered_map<std::string, menu_t> menu_lookup;

extern std::string display_stub_default;

// NOLINTEND

void read(const char* filename);

void insert(const char* code, const callback_f& callback);

int dynamic(const char* code, const display_f& disp);

int display_stub(std::size_t idx);

class menu_t

{

struct private_ctor_t

{

};

friend void read(const char* filename);

public:

// Tag type dispatch

menu_t(private_ctor_t, // NOLINT

const std::string& code,

const std::string& prompt)

: menu_t(code, prompt)

{

}

menu_t(const menu_t&) = delete;

menu_t& operator=(const menu_t&) = delete;

menu_t(menu_t&&) = delete;

menu_t& operator=(menu_t&&) = delete;

~menu_t() = default;

const std::string& code() const { return m_code; }

const std::string& title() const { return m_title; }

const auto& items() const { return m_items; }

auto& items() { return m_items; }

auto get_callback(std::size_t idx) const { return m_items[idx].callback; }

const auto& get_code(std::size_t idx) const { return m_codes[idx].code; }

const auto& get_prompt(std::size_t idx) const { return m_codes[idx].prompt; }

private:

menu_t(std::string code, std::string prompt)

: m_code(std::move(code))

, m_title(std::move(prompt))

{

}

void insert(const std::string& code,

const std::string& prompt,

const callback_f& callback = display_stub);

struct code_t

{

std::string code;

std::string prompt;

};

std::string m_code;

std::string m_title;

std::vector<code_t> m_codes;

std::vector<item_t> m_items;

};

} // namespace stamen

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

@@ -6,7 +6,7 @@ #include <cemplate/cemplate.hpp> #include <poafloc/poafloc.hpp>

#include "stamen/menu.hpp"

#include "stamen/stamen.hpp"

struct arguments_t {

@@ -16,7 +16,7 @@ struct arguments_t namespace {

auto accumulate_items(const stamen::menu::menu_t& lmenu)

auto accumulate_items(const stamen::menu_t& lmenu)

{ using namespace cemplate; // NOLINT

@@ -67,13 +67,13 @@ struct menu_t )"; ost << "// generated function\n";

for (const auto& [code, _] : stamen::menu::menu_lookup)

for (const auto& [code, _] : stamen::menu_lookup)

{ ost << func_decl(code, "int", {{"std::size_t", "/* unused */"}}); } ost << "\n// free function\n";

for (const auto& [code, _] : stamen::menu::free_lookup)

for (const auto& [code, _] : stamen::free_lookup)

{ ost << func_decl(code, "int", {{"std::size_t", "/* unused */"}}); }

@@ -96,7 +96,7 @@ void generate_source(std::ostream& ost, ost << nspace(args.nspace); // clang-format off

for (const auto& [code, menu] : stamen::menu::menu_lookup)

for (const auto& [code, menu] : stamen::menu_lookup)

{ ost << func( menu.code(),

@@ -171,7 +171,7 @@ int main(int argc, char* argv[]) } const auto& config = args.config;

stamen::menu::read(config.c_str());

stamen::read(config.c_str());

const auto include_filename = args.config.stem().replace_extension(".hpp"); std::ofstream include(include_filename);

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

@@ -1,115 +0,0 @@

#include <deque>

#include <fstream>

#include <iostream>

#include <sstream>

#include <tuple>

#include <unordered_set>

#include <utility>

#include "stamen/menu.hpp"

namespace stamen::menu {

// NOLINTBEGIN

std::unordered_map<std::string, menu_t> menu_lookup;

std::unordered_map<std::string, callback_f> free_lookup;

std::string display_stub_default;

display_f display;

// NOLINTEND

void read(const char* filename)

{

std::unordered_set<std::string> refd;

std::fstream fst(filename);

std::string line;

std::string delim;

std::string code;

std::string prompt;

auto last = menu_lookup.end();

while (std::getline(fst, line))

{

if (line.empty()) continue;

std::istringstream iss(line);

iss >> delim >> code >> std::ws;

std::getline(iss, prompt);

if (delim != "+")

{

last->second.insert(code, prompt);

refd.insert(code);

}

else

{

const auto [iter, succ] = menu_lookup.emplace(

std::piecewise_construct,

std::forward_as_tuple(code),

std::forward_as_tuple(menu_t::private_ctor_t {}, code, prompt));

last = iter;

}

}

for (const auto& ref : refd)

{

if (!menu_lookup.contains(ref))

{

free_lookup.emplace(ref, nullptr);

}

}

}

void insert(const char* code, const callback_f& callback)

{

auto itr = free_lookup.find(code);

if (itr == free_lookup.end())

{

std::cout << "Stamen: unknown callback registration...\n" << std::flush;

return;

}

free_lookup.emplace(code, callback);

}

int dynamic(const char* code, const display_f& disp)

{

menu::display_stub_default = code;

menu::display = disp;

return display_stub(0);

}

int display_stub(std::size_t idx)

{

static std::deque<const menu_t*> stack;

const std::string& code =

!stack.empty() ? stack.back()->get_code(idx) : display_stub_default;

const auto ml_it = menu_lookup.find(code);

if (ml_it != menu_lookup.end())

{

stack.push_back(&ml_it->second);

const int ret = display(ml_it->second);

stack.pop_back();

return ret;

}

const auto fl_it = free_lookup.find(code);

if (fl_it != free_lookup.end()) return fl_it->second(0);

std::cout << "Stamen: nothing to do...\n" << std::flush;

return 1;

}

void menu_t::insert(const std::string& code,

const std::string& prompt,

const callback_f& callback)

{

char* buffer = new char[prompt.size() + 1]; // NOLINT

strcpy(buffer, prompt.c_str()); // NOLINT

m_items.emplace_back(callback, buffer);

m_codes.emplace_back(code, prompt);

}

} // namespace stamen::menu

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

@@ -0,0 +1,117 @@

#include <cstddef>

#include <deque>

#include <fstream>

#include <iostream>

#include <sstream>

#include <string>

#include <tuple>

#include <unordered_set>

#include <utility>

#include "stamen/stamen.hpp"

namespace stamen {

// NOLINTBEGIN

std::unordered_map<std::string, menu_t> menu_lookup;

std::unordered_map<std::string, callback_f> free_lookup;

std::string display_stub_default;

display_f display;

// NOLINTEND

void read(const char* filename)

{

std::unordered_set<std::string> refd;

std::fstream fst(filename);

std::string line;

std::string delim;

std::string code;

std::string prompt;

auto last = menu_lookup.end();

while (std::getline(fst, line))

{

if (line.empty()) continue;

std::istringstream iss(line);

iss >> delim >> code >> std::ws;

std::getline(iss, prompt);

if (delim != "+")

{

last->second.insert(code, prompt);

refd.insert(code);

}

else

{

const auto [iter, succ] = menu_lookup.emplace(

std::piecewise_construct,

std::forward_as_tuple(code),

std::forward_as_tuple(menu_t::private_ctor_t {}, code, prompt));

last = iter;

}

}

for (const auto& ref : refd)

{

if (!menu_lookup.contains(ref))

{

free_lookup.emplace(ref, nullptr);

}

}

}

void insert(const char* code, const callback_f& callback)

{

auto itr = free_lookup.find(code);

if (itr == free_lookup.end())

{

std::cout << "Stamen: unknown callback registration...\n" << std::flush;

return;

}

free_lookup.emplace(code, callback);

}

int dynamic(const char* code, const display_f& disp)

{

display_stub_default = code;

display = disp;

return display_stub(0);

}

int display_stub(std::size_t idx)

{

static std::deque<const menu_t*> stack;

const std::string& code =

!stack.empty() ? stack.back()->get_code(idx) : display_stub_default;

const auto ml_it = menu_lookup.find(code);

if (ml_it != menu_lookup.end())

{

stack.push_back(&ml_it->second);

const int ret = display(ml_it->second);

stack.pop_back();

return ret;

}

const auto fl_it = free_lookup.find(code);

if (fl_it != free_lookup.end()) return fl_it->second(0);

std::cout << "Stamen: nothing to do...\n" << std::flush;

return 1;

}

void menu_t::insert(const std::string& code,

const std::string& prompt,

const callback_f& callback)

{

char* buffer = new char[prompt.size() + 1]; // NOLINT

strcpy(buffer, prompt.c_str()); // NOLINT

m_items.emplace_back(callback, buffer);

m_codes.emplace_back(code, prompt);

}

} // namespace stamen