fixed namespaces;

formatted tester.cpp for other people;

created additional static functions;

added enum description support;

Author: Ross Lombardi

enum_reader/enum_reader.cpp

@@ -11,7 +11,7 @@ const string enum_header_name_text = R"(enum class ([A-z]+))";
 const string enum_header_type_text = R"((:|: )([A-z]+))"; // 2nd group is what we take
 const string enum_header_nspace_text = R"(\/\/ns@([A-z]+))";
 
-const string enum_value_name_text = R"(^\s([A-z_]+))";
+const string enum_value_name_text = R"(^[\s]*([A-z_]+))";
 const string enum_value_expr_text = R"(=([0-9A-z\-| ]+))";
 const string enum_value_comment_text = R"(\/\/([ A-z0-9!?]+))";
 
@@ -304,16 +304,25 @@ string create_enum_map_data(enum_data const& data)
     // and the reverse
     string map_text;
 
-    map_text.append("enum class " + data.full_name() + " : " + data.type + ";\r");
+    if (data.nspace.empty())
+    {
+        map_text.append("enum class " + data.name + " : " + data.type + ";\r");
+    }
+    else
+    {
+        map_text.append("namespace " + data.nspace + "\r{\r\tenum class " + data.name + " : " + data.type + "; \r}\r");
+    }
+   
+    map_text.append("const std::string enum_static<" + data.full_name() + ">::enum_desc = \"" + data.comment + "\";\r");
 
-    map_text.append("const std::unordered_map<" + data.type + ", std::string> enum_static<" + data.name + ">::value_to_name = {\r");
+    map_text.append("const std::unordered_map<" + data.type + ", std::string> enum_static<" + data.full_name() + ">::value_to_name = {\r");
 
     for (auto& enum_value : data.values)
     {
         map_text.append("\t{ " + to_string(enum_value.value) + ", \"" + enum_value.name + "\" }, \r");
     }
     map_text.append(" };\r");
-    map_text.append("const std::unordered_map<std::string, " + data.type + "> enum_static<" + data.name + ">::name_to_value = {\r");
+    map_text.append("const std::unordered_map<std::string, " + data.type + "> enum_static<" + data.full_name() + ">::name_to_value = {\r");
 
     for (auto& enum_value : data.values)
     {

enum_values/enum_values.cpp

@@ -2,6 +2,7 @@
 #include "enum_values.h"
 
 enum class myvalues : int;
+const std::string enum_static<myvalues>::enum_desc = "these values are used by those values, top kek!";
 const std::unordered_map<int, std::string> enum_static<myvalues>::value_to_name = {
 	{ 0, "zero" },
 	{ 1, "one" },
@@ -22,6 +23,7 @@ const std::unordered_map<std::string, int> enum_static<myvalues>::name_to_value
 };
 
 enum class yourvalues : int;
+const std::string enum_static<yourvalues>::enum_desc = "";
 const std::unordered_map<int, std::string> enum_static<yourvalues>::value_to_name = {
 	{ 0, "zero" },
 	{ 1, "one" },
@@ -41,8 +43,12 @@ const std::unordered_map<std::string, int> enum_static<yourvalues>::name_to_valu
 	{ "five", 5 },
 };
 
-enum class theirvalues : int;
-const std::unordered_map<int, std::string> enum_static<theirvalues>::value_to_name = {
+namespace espace
+{
+	enum class theirvalues : int;
+}
+const std::string enum_static<espace::theirvalues>::enum_desc = "";
+const std::unordered_map<int, std::string> enum_static<espace::theirvalues>::value_to_name = {
 	{ 0, "zero" },
 	{ 1, "one" },
 	{ 2, "two" },
@@ -51,7 +57,7 @@ const std::unordered_map<int, std::string> enum_static<theirvalues>::value_to_na
 	{ 4, "four" },
 	{ 5, "five" },
 };
-const std::unordered_map<std::string, int> enum_static<theirvalues>::name_to_value = {
+const std::unordered_map<std::string, int> enum_static<espace::theirvalues>::name_to_value = {
 	{ "zero", 0 },
 	{ "one", 1 },
 	{ "two", 2 },
@@ -60,3 +66,4 @@ const std::unordered_map<std::string, int> enum_static<theirvalues>::name_to_val
 	{ "four", 4 },
 	{ "five", 5 },
 };
+

enum_values/enum_values.h

@@ -11,6 +11,7 @@ class enum_static
 private:
 	static const std::unordered_map<_UTy, std::string> value_to_name;
 	static const std::unordered_map<std::string, _UTy> name_to_value;
+	static const std::string enum_desc;
 
 public:
 
@@ -19,11 +20,31 @@ class enum_static
 		return value_to_name;
 	}
 
-	static const auto iterable_by_name()
+	static const auto iterable_by_names()
 	{
 		return value_to_name;
 	}
 
+	static const auto description()
+	{
+		return enum_desc;
+	}
+
+	static _ETy flag_set(_ETy value, _ETy flag)
+	{
+		return static_cast<_UTy>(value) | static_cast<_UTy>(flag);
+	}
+
+	static _ETy flag_remove(_ETy value, _ETy flag)
+	{
+		return static_cast<_UTy>(value) & ~static_cast<_UTy>(flag);
+	}
+
+	static _ETy flag_toggle(_ETy value, _ETy flag)
+	{
+		return static_cast<_UTy>(value) ^ static_cast<_UTy>(flag);
+	}
+
 	template<typename Ty>
 	requires std::is_same_v<_ETy, Ty> || std::is_same_v<_UTy, Ty>
 		static bool has_flag(Ty value, _UTy other)
@@ -154,12 +175,12 @@ class enum_value
 
 	bool has_flag(_UTy other) const
 	{
-		return has_flag(_value, other);
+		return enum_static<_ETy>::has_flag(_value, other);
 	}
 
 	bool has_flag(_ETy other) const
 	{
-		return has_flag(other, static_cast<_UTy>(other));
+		return enum_static<_ETy>::has_flag(other, static_cast<_UTy>(other));
 	}
 
 	enum_value& operator=(const enum_value& other)
@@ -180,17 +201,17 @@ class enum_value
 
 	void flag_set(_ETy flag)
 	{
-		_value |= static_cast<_UTy>(flag);
+		_value = enum_static<_ETy>::flag_set(_value, flag);
 	}
 
 	void flag_remove(_ETy flag)
 	{
-		_value &= ~static_cast<_UTy>(flag);
+		_value = enum_static<_ETy>::flag_remove(_value, flag);
 	}
 
 	void flag_toggle(_ETy flag)
 	{
-		_value ^= static_cast<_UTy>(flag);
+		_value = enum_static<_ETy>::flag_toggle(_value, flag);
 	}
 
 	enum_value& operator++()

enum_values/tester.cpp

@@ -30,60 +30,88 @@ enum class yourvalues : int
 	five,
 };
 
-enum class theirvalues : int //ns@ourvalues
+namespace espace
 {
-	zero, // nope
-	one,
-	two,
-	also_two = two, // does it work?
-	three, // ah!!
-	four,
-	five,
-};
+	enum class theirvalues : int //ns@espace
+	{
+		zero, // nope
+		one,
+		two,
+		also_two = two, // does it work?
+		three, // ah!!
+		four,
+		five,
+	};
+}
 
-void that(myvalues v)
+void foo(myvalues v)
 {
-	v = myvalues::also_three;
+	v = myvalues::also_three; // this line brought to you by compiler warnings
 }
 
 int main()
 {
+	// get description
+	std::cout << enum_static<myvalues>::description() << std::endl;
+	std::cout << enum_static<espace::theirvalues>::description() << std::endl;
+
+	// using the enum_value class to hold values (useful for flags
 	enum_value<myvalues> val1;
 	enum_value<myvalues> val2;
 
+	// reset to 0
+	val1.clear();
+
+	// assign to enum
 	val1 = myvalues::two;
+
+	// assignment by data()
 	val1.data() = 10;
-	val1.clear();
+	val2.data() = 5;
+
+	// assignment by enum directly
+	*val1 = myvalues::three;
+
 	auto ok = (val1.data() == 5);
+
+	// comparison of two enum_values
 	ok = (val1 == val2);
+
+	// comparison by enum
 	ok = (val1 == myvalues::three);
+
+	// enum_value asignment
 	val1 = val2;
-	val2.data() = 5;
-	*val1 = myvalues::three;
 
 	auto c = val1.data();
 	std::cout << c << std::endl;
 
-	for (auto v : enum_static<myvalues>::iterable_by_name())
+	// iterate over full list of values
+	for (auto v : enum_static<myvalues>::iterable_by_names())
 	{
 		std::cout << v.second << std::endl;
 	}
 
+	// assign by string
 	val1.from_string("zero");
 	std::cout << val1.to_string() << std::endl;
 
+	// assign by string flag
 	auto unknowns = val1.from_flag_string("one!+!two!+!four", "!+!");
 	assert(unknowns.empty());
 
+	// detect unknown flag text
 	unknowns = val1.from_flag_string("one+two+four", "!+!");
 	assert(unknowns == "one+two+four");
 
 	unknowns = val1.from_flag_string("eight+sixteen+two+four+thirty-two", "+");
 	assert(unknowns == "eight+sixteen+thirty-two");
 
+	// to flag string
 	std::cout << val1.to_flag_string("+") << std::endl;
 
-	that(*val1);
+	// pass enum direct
+	foo(*val1);
 
 	return 0;
 }