From fd31e462d8acac7af890dad7dff8de76c1caa1a3 Mon Sep 17 00:00:00 2001
From: Mikko Rasa <tdb@tdb.fi>
Date: Tue, 19 Dec 2017 11:12:48 +0200
Subject: [PATCH] Add lexical conversions for BlendFactor and Predicate

---
 source/blend.cpp     | 60 ++++++++++++++++++++++++++++++++++++++++++++
 source/blend.h       |  4 +++
 source/predicate.cpp | 49 ++++++++++++++++++++++++++++++++++++
 source/predicate.h   |  4 +++
 4 files changed, 117 insertions(+)
 create mode 100644 source/predicate.cpp

diff --git a/source/blend.cpp b/source/blend.cpp
index df4043e2..3327885c 100644
--- a/source/blend.cpp
+++ b/source/blend.cpp
@@ -1,7 +1,10 @@
 #include <msp/gl/extensions/ext_blend_minmax.h>
 #include <msp/gl/extensions/ext_blend_subtract.h>
+#include <msp/strings/format.h>
 #include "blend.h"
 
+using namespace std;
+
 namespace Msp {
 namespace GL {
 
@@ -63,5 +66,62 @@ const Blend &Blend::additive_alpha()
 	return blend;
 }
 
+void operator>>(const LexicalConverter &conv, BlendFactor &factor)
+{
+	const string &str = conv.get();
+	if(str=="ZERO")
+		factor = ZERO;
+	else if(str=="ONE")
+		factor = ONE;
+	else if(str=="SRC_COLOR")
+		factor = SRC_COLOR;
+	else if(str=="ONE_MINUS_SRC_COLOR")
+		factor = ONE_MINUS_SRC_COLOR;
+	else if(str=="SRC_ALPHA")
+		factor = SRC_ALPHA;
+	else if(str=="ONE_MINUS_SRC_ALPHA")
+		factor = ONE_MINUS_SRC_ALPHA;
+	else if(str=="DST_COLOR")
+		factor = DST_COLOR;
+	else if(str=="ONE_MINUS_DST_COLOR")
+		factor = ONE_MINUS_DST_COLOR;
+	else if(str=="DST_ALPHA")
+		factor = DST_ALPHA;
+	else if(str=="ONE_MINUS_DST_ALPHA")
+		factor = ONE_MINUS_DST_ALPHA;
+	else if(str=="CONSTANT_COLOR")
+		factor = CONSTANT_COLOR;
+	else if(str=="ONE_MINUS_CONSTANT_COLOR")
+		factor = ONE_MINUS_CONSTANT_COLOR;
+	else if(str=="CONSTANT_ALPHA")
+		factor = CONSTANT_ALPHA;
+	else if(str=="ONE_MINUS_CONSTANT_ALPHA")
+		factor = ONE_MINUS_CONSTANT_ALPHA;
+	else
+		throw lexical_error(format("conversion of '%s' to BlendFactor", str));
+}
+
+void operator<<(LexicalConverter &conv, BlendFactor factor)
+{
+	switch(factor)
+	{
+	case ZERO: conv.result("ZERO"); break;
+	case ONE: conv.result("ONE"); break;
+	case SRC_COLOR: conv.result("SRC_COLOR"); break;
+	case ONE_MINUS_SRC_COLOR: conv.result("ONE_MINUS_SRC_COLOR"); break;
+	case SRC_ALPHA: conv.result("SRC_ALPHA"); break;
+	case ONE_MINUS_SRC_ALPHA: conv.result("ONE_MINUS_SRC_ALPHA"); break;
+	case DST_COLOR: conv.result("DST_COLOR"); break;
+	case ONE_MINUS_DST_COLOR: conv.result("ONE_MINUS_DST_COLOR"); break;
+	case DST_ALPHA: conv.result("DST_ALPHA"); break;
+	case ONE_MINUS_DST_ALPHA: conv.result("ONE_MINUS_DST_ALPHA"); break;
+	case CONSTANT_COLOR: conv.result("CONSTANT_COLOR"); break;
+	case ONE_MINUS_CONSTANT_COLOR: conv.result("ONE_MINUS_CONSTANT_COLOR"); break;
+	case CONSTANT_ALPHA: conv.result("CONSTANT_ALPHA"); break;
+	case ONE_MINUS_CONSTANT_ALPHA: conv.result("ONE_MINUS_CONSTANT_ALPHA"); break;
+	default: conv.result(format("BlendFactor(%#x)", static_cast<int>(factor)));
+	}
+}
+
 } // namespace GL
 } // namespace Msp
diff --git a/source/blend.h b/source/blend.h
index 41567c53..e7b291e6 100644
--- a/source/blend.h
+++ b/source/blend.h
@@ -1,6 +1,7 @@
 #ifndef MSP_GL_BLEND_H_
 #define MSP_GL_BLEND_H_
 
+#include <msp/strings/lexicalcast.h>
 #include "bindable.h"
 #include "gl.h"
 #include <msp/gl/extensions/ext_blend_minmax.h>
@@ -59,6 +60,9 @@ public:
 	static const Blend &additive_alpha();
 };
 
+void operator>>(const LexicalConverter &, BlendFactor &);
+void operator<<(LexicalConverter &, BlendFactor);
+
 } // namespace GL
 } // namespace Msp
 
diff --git a/source/predicate.cpp b/source/predicate.cpp
new file mode 100644
index 00000000..a1953733
--- /dev/null
+++ b/source/predicate.cpp
@@ -0,0 +1,49 @@
+#include <msp/strings/format.h>
+#include "predicate.h"
+
+using namespace std;
+
+namespace Msp {
+namespace GL {
+
+void operator>>(const LexicalConverter &conv, Predicate &pred)
+{
+	const string &str = conv.get();
+	if(str=="NEVER")
+		pred = NEVER;
+	else if(str=="ALWAYS")
+		pred = ALWAYS;
+	else if(str=="LESS")
+		pred = LESS;
+	else if(str=="LEQUAL")
+		pred = LEQUAL;
+	else if(str=="EQUAL")
+		pred = EQUAL;
+	else if(str=="GREATER")
+		pred = GREATER;
+	else if(str=="GEQUAL")
+		pred = GEQUAL;
+	else if(str=="NOTEQUAL")
+		pred = NOTEQUAL;
+	else
+		throw lexical_error(format("conversion of '%s' to Predicate", str));
+}
+
+void operator<<(LexicalConverter &conv, Predicate pred)
+{
+	switch(pred)
+	{
+	case NEVER: conv.result("NEVER"); break;
+	case ALWAYS: conv.result("ALWAYS"); break;
+	case LESS: conv.result("LESS"); break;
+	case LEQUAL: conv.result("LEQUAL"); break;
+	case EQUAL: conv.result("EQUAL"); break;
+	case GREATER: conv.result("GREATER"); break;
+	case GEQUAL: conv.result("GEQUAL"); break;
+	case NOTEQUAL: conv.result("NOTEQUAL"); break;
+	default: conv.result(format("Predicate(%#x)", static_cast<int>(pred))); break;
+	}
+}
+
+} // namespace GL
+} // namespace Msp
diff --git a/source/predicate.h b/source/predicate.h
index f7bb40d0..13c22e84 100644
--- a/source/predicate.h
+++ b/source/predicate.h
@@ -1,6 +1,7 @@
 #ifndef MSP_GL_PREDICATE_H_
 #define MSP_GL_PREDICATE_H_
 
+#include <msp/strings/lexicalcast.h>
 #include "gl.h"
 
 namespace Msp {
@@ -18,6 +19,9 @@ enum Predicate
 	NOTEQUAL = GL_NOTEQUAL
 };
 
+void operator>>(const LexicalConverter &, Predicate &);
+void operator<<(LexicalConverter &, Predicate);
+
 } // namespace GL
 } // namespace Msp
 
-- 
2.45.2