Add PointerList and EnvMap classes for working with, and propagating, argc/argv and env strings

1 files changed, 74 insertions, 0 deletions

diff --git a/src/pointerlist.h b/src/pointerlist.h
new file mode 100644
index 0000000..988bb26
--- /dev/null
+++ b/src/pointerlist.h
@@ -0,0 +1,74 @@
+// -*- c++ -*-
+// Distributed under the BSD 2-Clause License.
+// See accompanying file LICENSE for details.
+#pragma once
+
+#include <string>
+#include <vector>
+#include <deque>
+#include <utility>
+#include <map>
+
+//! Maintains an (owning) list of string args and converts them to argc/argv
+//! compatible arguments on request.
+//! The returned pointers are guaranteed to be valid as long as the PointerList
+//! object lifetime is not exceeded.
+class PointerList
+	: public std::deque<std::string>
+{
+public:
+	PointerList() = default;
+	PointerList(int argc, const char* const argv[]);
+
+	//! Returns argc/argv pair from the current list of args
+	//! The argv entry after the last is a nullptr (not included in the argc)
+	std::pair<int, const char* const*> get();
+
+private:
+	std::vector<const char*> argptrs;
+};
+
+
+//! Maintains an owning map of strings representing the env.
+class EnvMap
+{
+public:
+	EnvMap() = default;
+
+	//! Initialize from an array of pointers to key=value\0 strings terminated
+	//! by \0
+	EnvMap(const char* const env[]);
+
+	//! Initialize from a string of the format
+	//!  key1=val\0key2=val\0...keyN=val\0\0
+	EnvMap(const char* env);
+
+	std::string operator[](const std::string& key) const;
+
+	//! Clear all items in the map
+	void clear();
+
+	//! Insert string from format: key=value
+	void insert(std::string_view key_value);
+
+	//! Regular map insert
+	void insert(const std::pair<std::string_view, std::string_view>& item);
+
+	//! Checks if the container contains element with specific key
+	bool contains(std::string_view key) const;
+
+	std::size_t size() const;
+
+	//! Return string with the following format:
+	//!  key1=val\0key2=val\0...keyN=val\0\0
+	std::string stringify() const;
+
+	//! Returns the map as argc/argv pair where each pointer points to a string
+	//! of the format key=value\0 and is terminated with a nullptr
+	std::pair<int, const char* const*> get();
+
+private:
+	std::map<std::string, std::string> data{};
+
+	PointerList pointerlist;
+};