stamen

Static Menu Generator
git clone git://git.dimitrijedobrota.com/stamen.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING |
commite814fd0a34a1f28773e3551a76a341704fcc63e4
parenta5cb5bf5961c3321d890a0f5897689f76d2cc8ec
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateSun, 23 Feb 2025 17:20:01 +0100

Shuffle the code around

Diffstat:
MCMakeLists.txt|++--
Mexample/dynamic.cpp|++++++++++++++-------------
Mexample/static.cpp|+
Dinclude/stamen/menu.hpp|---------------------------------------------------------------------------------
Ainclude/stamen/stamen.hpp|+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Msource/generate.cpp|++++++------
Dsource/menu.cpp|---------------------------------------------------------------------------------
Asource/stamen.cpp|+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

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